pyparsing.py.html
1    <html>
2    <head>
3    <title>pyparsing.py</title>
4    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
5    <style type="text/css">
6    .s0 { color: #808080;}
7    .s1 { color: #a9b7c6;}
8    .s2 { color: #6a8759;}
9    .s3 { color: #cc7832;}
10   .s4 { color: #6897bb;}
11   .s5 { color: #629755; font-style: italic;}
12   .ln { color: #606366; font-weight: normal; font-style: normal; }
13   </style>
14   </head>
15   <body bgcolor="#2b2b2b">
16   <table CELLSPACING=0 CELLPADDING=5 COLS=1 WIDTH="100%" BGCOLOR="#606060" >
17   <tr><td><center>
18   <font face="Arial, Helvetica" color="#000000">
19   pyparsing.py</font>
20   </center></td></tr></table>
21   <pre><a name="l1"><span class="ln">1    </span></a><span class="s0"># -*- coding: utf-8 -*-</span>
22   <a name="l2"><span class="ln">2    </span></a><span class="s0"># module pyparsing.py</span>
23   <a name="l3"><span class="ln">3    </span></a><span class="s0">#</span>
24   <a name="l4"><span class="ln">4    </span></a><span class="s0"># Copyright (c) 2003-2019  Paul T. McGuire</span>
25   <a name="l5"><span class="ln">5    </span></a><span class="s0">#</span>
26   <a name="l6"><span class="ln">6    </span></a><span class="s0"># Permission is hereby granted, free of charge, to any person obtaining</span>
27   <a name="l7"><span class="ln">7    </span></a><span class="s0"># a copy of this software and associated documentation files (the</span>
28   <a name="l8"><span class="ln">8    </span></a><span class="s0"># &quot;Software&quot;), to deal in the Software without restriction, including</span>
29   <a name="l9"><span class="ln">9    </span></a><span class="s0"># without limitation the rights to use, copy, modify, merge, publish,</span>
30   <a name="l10"><span class="ln">10   </span></a><span class="s0"># distribute, sublicense, and/or sell copies of the Software, and to</span>
31   <a name="l11"><span class="ln">11   </span></a><span class="s0"># permit persons to whom the Software is furnished to do so, subject to</span>
32   <a name="l12"><span class="ln">12   </span></a><span class="s0"># the following conditions:</span>
33   <a name="l13"><span class="ln">13   </span></a><span class="s0">#</span>
34   <a name="l14"><span class="ln">14   </span></a><span class="s0"># The above copyright notice and this permission notice shall be</span>
35   <a name="l15"><span class="ln">15   </span></a><span class="s0"># included in all copies or substantial portions of the Software.</span>
36   <a name="l16"><span class="ln">16   </span></a><span class="s0">#</span>
37   <a name="l17"><span class="ln">17   </span></a><span class="s0"># THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND,</span>
38   <a name="l18"><span class="ln">18   </span></a><span class="s0"># EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF</span>
39   <a name="l19"><span class="ln">19   </span></a><span class="s0"># MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.</span>
40   <a name="l20"><span class="ln">20   </span></a><span class="s0"># IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY</span>
41   <a name="l21"><span class="ln">21   </span></a><span class="s0"># CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,</span>
42   <a name="l22"><span class="ln">22   </span></a><span class="s0"># TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE</span>
43   <a name="l23"><span class="ln">23   </span></a><span class="s0"># SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.</span>
44   <a name="l24"><span class="ln">24   </span></a><span class="s0">#</span>
45   <a name="l25"><span class="ln">25   </span></a>
46   <a name="l26"><span class="ln">26   </span></a><span class="s1">__doc__ = \</span>
47   <a name="l27"><span class="ln">27   </span></a><span class="s2">&quot;&quot;&quot; 
48   <a name="l28"><span class="ln">28   </span></a>pyparsing module - Classes and methods to define and execute parsing grammars 
49   <a name="l29"><span class="ln">29   </span></a>============================================================================= 
50   <a name="l30"><span class="ln">30   </span></a> 
51   <a name="l31"><span class="ln">31   </span></a>The pyparsing module is an alternative approach to creating and 
52   <a name="l32"><span class="ln">32   </span></a>executing simple grammars, vs. the traditional lex/yacc approach, or the 
53   <a name="l33"><span class="ln">33   </span></a>use of regular expressions.  With pyparsing, you don't need to learn 
54   <a name="l34"><span class="ln">34   </span></a>a new syntax for defining grammars or matching expressions - the parsing 
55   <a name="l35"><span class="ln">35   </span></a>module provides a library of classes that you use to construct the 
56   <a name="l36"><span class="ln">36   </span></a>grammar directly in Python. 
57   <a name="l37"><span class="ln">37   </span></a> 
58   <a name="l38"><span class="ln">38   </span></a>Here is a program to parse &quot;Hello, World!&quot; (or any greeting of the form 
59   <a name="l39"><span class="ln">39   </span></a>``&quot;&lt;salutation&gt;, &lt;addressee&gt;!&quot;``), built up using :class:`Word`, 
60   <a name="l40"><span class="ln">40   </span></a>:class:`Literal`, and :class:`And` elements 
61   <a name="l41"><span class="ln">41   </span></a>(the :class:`'+'&lt;ParserElement.__add__&gt;` operators create :class:`And` expressions, 
62   <a name="l42"><span class="ln">42   </span></a>and the strings are auto-converted to :class:`Literal` expressions):: 
63   <a name="l43"><span class="ln">43   </span></a> 
64   <a name="l44"><span class="ln">44   </span></a>    from pip._vendor.pyparsing import Word, alphas 
65   <a name="l45"><span class="ln">45   </span></a> 
66   <a name="l46"><span class="ln">46   </span></a>    # define grammar of a greeting 
67   <a name="l47"><span class="ln">47   </span></a>    greet = Word(alphas) + &quot;,&quot; + Word(alphas) + &quot;!&quot; 
68   <a name="l48"><span class="ln">48   </span></a> 
69   <a name="l49"><span class="ln">49   </span></a>    hello = &quot;Hello, World!&quot; 
70   <a name="l50"><span class="ln">50   </span></a>    print (hello, &quot;-&gt;&quot;, greet.parseString(hello)) 
71   <a name="l51"><span class="ln">51   </span></a> 
72   <a name="l52"><span class="ln">52   </span></a>The program outputs the following:: 
73   <a name="l53"><span class="ln">53   </span></a> 
74   <a name="l54"><span class="ln">54   </span></a>    Hello, World! -&gt; ['Hello', ',', 'World', '!'] 
75   <a name="l55"><span class="ln">55   </span></a> 
76   <a name="l56"><span class="ln">56   </span></a>The Python representation of the grammar is quite readable, owing to the 
77   <a name="l57"><span class="ln">57   </span></a>self-explanatory class names, and the use of '+', '|' and '^' operators. 
78   <a name="l58"><span class="ln">58   </span></a> 
79   <a name="l59"><span class="ln">59   </span></a>The :class:`ParseResults` object returned from 
80   <a name="l60"><span class="ln">60   </span></a>:class:`ParserElement.parseString` can be 
81   <a name="l61"><span class="ln">61   </span></a>accessed as a nested list, a dictionary, or an object with named 
82   <a name="l62"><span class="ln">62   </span></a>attributes. 
83   <a name="l63"><span class="ln">63   </span></a> 
84   <a name="l64"><span class="ln">64   </span></a>The pyparsing module handles some of the problems that are typically 
85   <a name="l65"><span class="ln">65   </span></a>vexing when writing text parsers: 
86   <a name="l66"><span class="ln">66   </span></a> 
87   <a name="l67"><span class="ln">67   </span></a>  - extra or missing whitespace (the above program will also handle 
88   <a name="l68"><span class="ln">68   </span></a>    &quot;Hello,World!&quot;, &quot;Hello  ,  World  !&quot;, etc.) 
89   <a name="l69"><span class="ln">69   </span></a>  - quoted strings 
90   <a name="l70"><span class="ln">70   </span></a>  - embedded comments 
91   <a name="l71"><span class="ln">71   </span></a> 
92   <a name="l72"><span class="ln">72   </span></a> 
93   <a name="l73"><span class="ln">73   </span></a>Getting Started - 
94   <a name="l74"><span class="ln">74   </span></a>----------------- 
95   <a name="l75"><span class="ln">75   </span></a>Visit the classes :class:`ParserElement` and :class:`ParseResults` to 
96   <a name="l76"><span class="ln">76   </span></a>see the base classes that most other pyparsing 
97   <a name="l77"><span class="ln">77   </span></a>classes inherit from. Use the docstrings for examples of how to: 
98   <a name="l78"><span class="ln">78   </span></a> 
99   <a name="l79"><span class="ln">79   </span></a> - construct literal match expressions from :class:`Literal` and 
100  <a name="l80"><span class="ln">80   </span></a>   :class:`CaselessLiteral` classes 
101  <a name="l81"><span class="ln">81   </span></a> - construct character word-group expressions using the :class:`Word` 
102  <a name="l82"><span class="ln">82   </span></a>   class 
103  <a name="l83"><span class="ln">83   </span></a> - see how to create repetitive expressions using :class:`ZeroOrMore` 
104  <a name="l84"><span class="ln">84   </span></a>   and :class:`OneOrMore` classes 
105  <a name="l85"><span class="ln">85   </span></a> - use :class:`'+'&lt;And&gt;`, :class:`'|'&lt;MatchFirst&gt;`, :class:`'^'&lt;Or&gt;`, 
106  <a name="l86"><span class="ln">86   </span></a>   and :class:`'&amp;'&lt;Each&gt;` operators to combine simple expressions into 
107  <a name="l87"><span class="ln">87   </span></a>   more complex ones 
108  <a name="l88"><span class="ln">88   </span></a> - associate names with your parsed results using 
109  <a name="l89"><span class="ln">89   </span></a>   :class:`ParserElement.setResultsName` 
110  <a name="l90"><span class="ln">90   </span></a> - access the parsed data, which is returned as a :class:`ParseResults` 
111  <a name="l91"><span class="ln">91   </span></a>   object 
112  <a name="l92"><span class="ln">92   </span></a> - find some helpful expression short-cuts like :class:`delimitedList` 
113  <a name="l93"><span class="ln">93   </span></a>   and :class:`oneOf` 
114  <a name="l94"><span class="ln">94   </span></a> - find more useful common expressions in the :class:`pyparsing_common` 
115  <a name="l95"><span class="ln">95   </span></a>   namespace class 
116  <a name="l96"><span class="ln">96   </span></a>&quot;&quot;&quot;</span>
117  <a name="l97"><span class="ln">97   </span></a>
118  <a name="l98"><span class="ln">98   </span></a><span class="s1">__version__ = </span><span class="s2">&quot;2.4.7&quot;</span>
119  <a name="l99"><span class="ln">99   </span></a><span class="s1">__versionTime__ = </span><span class="s2">&quot;30 Mar 2020 00:43 UTC&quot;</span>
120  <a name="l100"><span class="ln">100  </span></a><span class="s1">__author__ = </span><span class="s2">&quot;Paul McGuire &lt;ptmcg@users.sourceforge.net&gt;&quot;</span>
121  <a name="l101"><span class="ln">101  </span></a>
122  <a name="l102"><span class="ln">102  </span></a><span class="s3">import </span><span class="s1">string</span>
123  <a name="l103"><span class="ln">103  </span></a><span class="s3">from </span><span class="s1">weakref </span><span class="s3">import </span><span class="s1">ref </span><span class="s3">as </span><span class="s1">wkref</span>
124  <a name="l104"><span class="ln">104  </span></a><span class="s3">import </span><span class="s1">copy</span>
125  <a name="l105"><span class="ln">105  </span></a><span class="s3">import </span><span class="s1">sys</span>
126  <a name="l106"><span class="ln">106  </span></a><span class="s3">import </span><span class="s1">warnings</span>
127  <a name="l107"><span class="ln">107  </span></a><span class="s3">import </span><span class="s1">re</span>
128  <a name="l108"><span class="ln">108  </span></a><span class="s3">import </span><span class="s1">sre_constants</span>
129  <a name="l109"><span class="ln">109  </span></a><span class="s3">import </span><span class="s1">collections</span>
130  <a name="l110"><span class="ln">110  </span></a><span class="s3">import </span><span class="s1">pprint</span>
131  <a name="l111"><span class="ln">111  </span></a><span class="s3">import </span><span class="s1">traceback</span>
132  <a name="l112"><span class="ln">112  </span></a><span class="s3">import </span><span class="s1">types</span>
133  <a name="l113"><span class="ln">113  </span></a><span class="s3">from </span><span class="s1">datetime </span><span class="s3">import </span><span class="s1">datetime</span>
134  <a name="l114"><span class="ln">114  </span></a><span class="s3">from </span><span class="s1">operator </span><span class="s3">import </span><span class="s1">itemgetter</span>
135  <a name="l115"><span class="ln">115  </span></a><span class="s3">import </span><span class="s1">itertools</span>
136  <a name="l116"><span class="ln">116  </span></a><span class="s3">from </span><span class="s1">functools </span><span class="s3">import </span><span class="s1">wraps</span>
137  <a name="l117"><span class="ln">117  </span></a><span class="s3">from </span><span class="s1">contextlib </span><span class="s3">import </span><span class="s1">contextmanager</span>
138  <a name="l118"><span class="ln">118  </span></a>
139  <a name="l119"><span class="ln">119  </span></a><span class="s3">try</span><span class="s1">:</span>
140  <a name="l120"><span class="ln">120  </span></a>    <span class="s0"># Python 3</span>
141  <a name="l121"><span class="ln">121  </span></a>    <span class="s3">from </span><span class="s1">itertools </span><span class="s3">import </span><span class="s1">filterfalse</span>
142  <a name="l122"><span class="ln">122  </span></a><span class="s3">except </span><span class="s1">ImportError:</span>
143  <a name="l123"><span class="ln">123  </span></a>    <span class="s3">from </span><span class="s1">itertools </span><span class="s3">import </span><span class="s1">ifilterfalse </span><span class="s3">as </span><span class="s1">filterfalse</span>
144  <a name="l124"><span class="ln">124  </span></a>
145  <a name="l125"><span class="ln">125  </span></a><span class="s3">try</span><span class="s1">:</span>
146  <a name="l126"><span class="ln">126  </span></a>    <span class="s3">from </span><span class="s1">_thread </span><span class="s3">import </span><span class="s1">RLock</span>
147  <a name="l127"><span class="ln">127  </span></a><span class="s3">except </span><span class="s1">ImportError:</span>
148  <a name="l128"><span class="ln">128  </span></a>    <span class="s3">from </span><span class="s1">threading </span><span class="s3">import </span><span class="s1">RLock</span>
149  <a name="l129"><span class="ln">129  </span></a>
150  <a name="l130"><span class="ln">130  </span></a><span class="s3">try</span><span class="s1">:</span>
151  <a name="l131"><span class="ln">131  </span></a>    <span class="s0"># Python 3</span>
152  <a name="l132"><span class="ln">132  </span></a>    <span class="s3">from </span><span class="s1">collections.abc </span><span class="s3">import </span><span class="s1">Iterable</span>
153  <a name="l133"><span class="ln">133  </span></a>    <span class="s3">from </span><span class="s1">collections.abc </span><span class="s3">import </span><span class="s1">MutableMapping</span><span class="s3">, </span><span class="s1">Mapping</span>
154  <a name="l134"><span class="ln">134  </span></a><span class="s3">except </span><span class="s1">ImportError:</span>
155  <a name="l135"><span class="ln">135  </span></a>    <span class="s0"># Python 2.7</span>
156  <a name="l136"><span class="ln">136  </span></a>    <span class="s3">from </span><span class="s1">collections </span><span class="s3">import </span><span class="s1">Iterable</span>
157  <a name="l137"><span class="ln">137  </span></a>    <span class="s3">from </span><span class="s1">collections </span><span class="s3">import </span><span class="s1">MutableMapping</span><span class="s3">, </span><span class="s1">Mapping</span>
158  <a name="l138"><span class="ln">138  </span></a>
159  <a name="l139"><span class="ln">139  </span></a><span class="s3">try</span><span class="s1">:</span>
160  <a name="l140"><span class="ln">140  </span></a>    <span class="s3">from </span><span class="s1">collections </span><span class="s3">import </span><span class="s1">OrderedDict </span><span class="s3">as </span><span class="s1">_OrderedDict</span>
161  <a name="l141"><span class="ln">141  </span></a><span class="s3">except </span><span class="s1">ImportError:</span>
162  <a name="l142"><span class="ln">142  </span></a>    <span class="s3">try</span><span class="s1">:</span>
163  <a name="l143"><span class="ln">143  </span></a>        <span class="s3">from </span><span class="s1">ordereddict </span><span class="s3">import </span><span class="s1">OrderedDict </span><span class="s3">as </span><span class="s1">_OrderedDict</span>
164  <a name="l144"><span class="ln">144  </span></a>    <span class="s3">except </span><span class="s1">ImportError:</span>
165  <a name="l145"><span class="ln">145  </span></a>        <span class="s1">_OrderedDict = </span><span class="s3">None</span>
166  <a name="l146"><span class="ln">146  </span></a>
167  <a name="l147"><span class="ln">147  </span></a><span class="s3">try</span><span class="s1">:</span>
168  <a name="l148"><span class="ln">148  </span></a>    <span class="s3">from </span><span class="s1">types </span><span class="s3">import </span><span class="s1">SimpleNamespace</span>
169  <a name="l149"><span class="ln">149  </span></a><span class="s3">except </span><span class="s1">ImportError:</span>
170  <a name="l150"><span class="ln">150  </span></a>    <span class="s3">class </span><span class="s1">SimpleNamespace: </span><span class="s3">pass</span>
171  <a name="l151"><span class="ln">151  </span></a>
172  <a name="l152"><span class="ln">152  </span></a><span class="s0"># version compatibility configuration</span>
173  <a name="l153"><span class="ln">153  </span></a><span class="s1">__compat__ = SimpleNamespace()</span>
174  <a name="l154"><span class="ln">154  </span></a><span class="s1">__compat__.__doc__ = </span><span class="s2">&quot;&quot;&quot; 
175  <a name="l155"><span class="ln">155  </span></a>    A cross-version compatibility configuration for pyparsing features that will be 
176  <a name="l156"><span class="ln">156  </span></a>    released in a future version. By setting values in this configuration to True, 
177  <a name="l157"><span class="ln">157  </span></a>    those features can be enabled in prior versions for compatibility development 
178  <a name="l158"><span class="ln">158  </span></a>    and testing. 
179  <a name="l159"><span class="ln">159  </span></a> 
180  <a name="l160"><span class="ln">160  </span></a>     - collect_all_And_tokens - flag to enable fix for Issue #63 that fixes erroneous grouping 
181  <a name="l161"><span class="ln">161  </span></a>       of results names when an And expression is nested within an Or or MatchFirst; set to 
182  <a name="l162"><span class="ln">162  </span></a>       True to enable bugfix released in pyparsing 2.3.0, or False to preserve 
183  <a name="l163"><span class="ln">163  </span></a>       pre-2.3.0 handling of named results 
184  <a name="l164"><span class="ln">164  </span></a>&quot;&quot;&quot;</span>
185  <a name="l165"><span class="ln">165  </span></a><span class="s1">__compat__.collect_all_And_tokens = </span><span class="s3">True</span>
186  <a name="l166"><span class="ln">166  </span></a>
187  <a name="l167"><span class="ln">167  </span></a><span class="s1">__diag__ = SimpleNamespace()</span>
188  <a name="l168"><span class="ln">168  </span></a><span class="s1">__diag__.__doc__ = </span><span class="s2">&quot;&quot;&quot; 
189  <a name="l169"><span class="ln">169  </span></a>Diagnostic configuration (all default to False) 
190  <a name="l170"><span class="ln">170  </span></a>     - warn_multiple_tokens_in_named_alternation - flag to enable warnings when a results 
191  <a name="l171"><span class="ln">171  </span></a>       name is defined on a MatchFirst or Or expression with one or more And subexpressions 
192  <a name="l172"><span class="ln">172  </span></a>       (only warns if __compat__.collect_all_And_tokens is False) 
193  <a name="l173"><span class="ln">173  </span></a>     - warn_ungrouped_named_tokens_in_collection - flag to enable warnings when a results 
194  <a name="l174"><span class="ln">174  </span></a>       name is defined on a containing expression with ungrouped subexpressions that also 
195  <a name="l175"><span class="ln">175  </span></a>       have results names 
196  <a name="l176"><span class="ln">176  </span></a>     - warn_name_set_on_empty_Forward - flag to enable warnings whan a Forward is defined 
197  <a name="l177"><span class="ln">177  </span></a>       with a results name, but has no contents defined 
198  <a name="l178"><span class="ln">178  </span></a>     - warn_on_multiple_string_args_to_oneof - flag to enable warnings whan oneOf is 
199  <a name="l179"><span class="ln">179  </span></a>       incorrectly called with multiple str arguments 
200  <a name="l180"><span class="ln">180  </span></a>     - enable_debug_on_named_expressions - flag to auto-enable debug on all subsequent 
201  <a name="l181"><span class="ln">181  </span></a>       calls to ParserElement.setName() 
202  <a name="l182"><span class="ln">182  </span></a>&quot;&quot;&quot;</span>
203  <a name="l183"><span class="ln">183  </span></a><span class="s1">__diag__.warn_multiple_tokens_in_named_alternation = </span><span class="s3">False</span>
204  <a name="l184"><span class="ln">184  </span></a><span class="s1">__diag__.warn_ungrouped_named_tokens_in_collection = </span><span class="s3">False</span>
205  <a name="l185"><span class="ln">185  </span></a><span class="s1">__diag__.warn_name_set_on_empty_Forward = </span><span class="s3">False</span>
206  <a name="l186"><span class="ln">186  </span></a><span class="s1">__diag__.warn_on_multiple_string_args_to_oneof = </span><span class="s3">False</span>
207  <a name="l187"><span class="ln">187  </span></a><span class="s1">__diag__.enable_debug_on_named_expressions = </span><span class="s3">False</span>
208  <a name="l188"><span class="ln">188  </span></a><span class="s1">__diag__._all_names = [nm </span><span class="s3">for </span><span class="s1">nm </span><span class="s3">in </span><span class="s1">vars(__diag__) </span><span class="s3">if </span><span class="s1">nm.startswith(</span><span class="s2">&quot;enable_&quot;</span><span class="s1">) </span><span class="s3">or </span><span class="s1">nm.startswith(</span><span class="s2">&quot;warn_&quot;</span><span class="s1">)]</span>
209  <a name="l189"><span class="ln">189  </span></a>
210  <a name="l190"><span class="ln">190  </span></a><span class="s3">def </span><span class="s1">_enable_all_warnings():</span>
211  <a name="l191"><span class="ln">191  </span></a>    <span class="s1">__diag__.warn_multiple_tokens_in_named_alternation = </span><span class="s3">True</span>
212  <a name="l192"><span class="ln">192  </span></a>    <span class="s1">__diag__.warn_ungrouped_named_tokens_in_collection = </span><span class="s3">True</span>
213  <a name="l193"><span class="ln">193  </span></a>    <span class="s1">__diag__.warn_name_set_on_empty_Forward = </span><span class="s3">True</span>
214  <a name="l194"><span class="ln">194  </span></a>    <span class="s1">__diag__.warn_on_multiple_string_args_to_oneof = </span><span class="s3">True</span>
215  <a name="l195"><span class="ln">195  </span></a><span class="s1">__diag__.enable_all_warnings = _enable_all_warnings</span>
216  <a name="l196"><span class="ln">196  </span></a>
217  <a name="l197"><span class="ln">197  </span></a>
218  <a name="l198"><span class="ln">198  </span></a><span class="s1">__all__ = [</span><span class="s2">'__version__'</span><span class="s3">, </span><span class="s2">'__versionTime__'</span><span class="s3">, </span><span class="s2">'__author__'</span><span class="s3">, </span><span class="s2">'__compat__'</span><span class="s3">, </span><span class="s2">'__diag__'</span><span class="s3">,</span>
219  <a name="l199"><span class="ln">199  </span></a>           <span class="s2">'And'</span><span class="s3">, </span><span class="s2">'CaselessKeyword'</span><span class="s3">, </span><span class="s2">'CaselessLiteral'</span><span class="s3">, </span><span class="s2">'CharsNotIn'</span><span class="s3">, </span><span class="s2">'Combine'</span><span class="s3">, </span><span class="s2">'Dict'</span><span class="s3">, </span><span class="s2">'Each'</span><span class="s3">, </span><span class="s2">'Empty'</span><span class="s3">,</span>
220  <a name="l200"><span class="ln">200  </span></a>           <span class="s2">'FollowedBy'</span><span class="s3">, </span><span class="s2">'Forward'</span><span class="s3">, </span><span class="s2">'GoToColumn'</span><span class="s3">, </span><span class="s2">'Group'</span><span class="s3">, </span><span class="s2">'Keyword'</span><span class="s3">, </span><span class="s2">'LineEnd'</span><span class="s3">, </span><span class="s2">'LineStart'</span><span class="s3">, </span><span class="s2">'Literal'</span><span class="s3">,</span>
221  <a name="l201"><span class="ln">201  </span></a>           <span class="s2">'PrecededBy'</span><span class="s3">, </span><span class="s2">'MatchFirst'</span><span class="s3">, </span><span class="s2">'NoMatch'</span><span class="s3">, </span><span class="s2">'NotAny'</span><span class="s3">, </span><span class="s2">'OneOrMore'</span><span class="s3">, </span><span class="s2">'OnlyOnce'</span><span class="s3">, </span><span class="s2">'Optional'</span><span class="s3">, </span><span class="s2">'Or'</span><span class="s3">,</span>
222  <a name="l202"><span class="ln">202  </span></a>           <span class="s2">'ParseBaseException'</span><span class="s3">, </span><span class="s2">'ParseElementEnhance'</span><span class="s3">, </span><span class="s2">'ParseException'</span><span class="s3">, </span><span class="s2">'ParseExpression'</span><span class="s3">, </span><span class="s2">'ParseFatalException'</span><span class="s3">,</span>
223  <a name="l203"><span class="ln">203  </span></a>           <span class="s2">'ParseResults'</span><span class="s3">, </span><span class="s2">'ParseSyntaxException'</span><span class="s3">, </span><span class="s2">'ParserElement'</span><span class="s3">, </span><span class="s2">'QuotedString'</span><span class="s3">, </span><span class="s2">'RecursiveGrammarException'</span><span class="s3">,</span>
224  <a name="l204"><span class="ln">204  </span></a>           <span class="s2">'Regex'</span><span class="s3">, </span><span class="s2">'SkipTo'</span><span class="s3">, </span><span class="s2">'StringEnd'</span><span class="s3">, </span><span class="s2">'StringStart'</span><span class="s3">, </span><span class="s2">'Suppress'</span><span class="s3">, </span><span class="s2">'Token'</span><span class="s3">, </span><span class="s2">'TokenConverter'</span><span class="s3">,</span>
225  <a name="l205"><span class="ln">205  </span></a>           <span class="s2">'White'</span><span class="s3">, </span><span class="s2">'Word'</span><span class="s3">, </span><span class="s2">'WordEnd'</span><span class="s3">, </span><span class="s2">'WordStart'</span><span class="s3">, </span><span class="s2">'ZeroOrMore'</span><span class="s3">, </span><span class="s2">'Char'</span><span class="s3">,</span>
226  <a name="l206"><span class="ln">206  </span></a>           <span class="s2">'alphanums'</span><span class="s3">, </span><span class="s2">'alphas'</span><span class="s3">, </span><span class="s2">'alphas8bit'</span><span class="s3">, </span><span class="s2">'anyCloseTag'</span><span class="s3">, </span><span class="s2">'anyOpenTag'</span><span class="s3">, </span><span class="s2">'cStyleComment'</span><span class="s3">, </span><span class="s2">'col'</span><span class="s3">,</span>
227  <a name="l207"><span class="ln">207  </span></a>           <span class="s2">'commaSeparatedList'</span><span class="s3">, </span><span class="s2">'commonHTMLEntity'</span><span class="s3">, </span><span class="s2">'countedArray'</span><span class="s3">, </span><span class="s2">'cppStyleComment'</span><span class="s3">, </span><span class="s2">'dblQuotedString'</span><span class="s3">,</span>
228  <a name="l208"><span class="ln">208  </span></a>           <span class="s2">'dblSlashComment'</span><span class="s3">, </span><span class="s2">'delimitedList'</span><span class="s3">, </span><span class="s2">'dictOf'</span><span class="s3">, </span><span class="s2">'downcaseTokens'</span><span class="s3">, </span><span class="s2">'empty'</span><span class="s3">, </span><span class="s2">'hexnums'</span><span class="s3">,</span>
229  <a name="l209"><span class="ln">209  </span></a>           <span class="s2">'htmlComment'</span><span class="s3">, </span><span class="s2">'javaStyleComment'</span><span class="s3">, </span><span class="s2">'line'</span><span class="s3">, </span><span class="s2">'lineEnd'</span><span class="s3">, </span><span class="s2">'lineStart'</span><span class="s3">, </span><span class="s2">'lineno'</span><span class="s3">,</span>
230  <a name="l210"><span class="ln">210  </span></a>           <span class="s2">'makeHTMLTags'</span><span class="s3">, </span><span class="s2">'makeXMLTags'</span><span class="s3">, </span><span class="s2">'matchOnlyAtCol'</span><span class="s3">, </span><span class="s2">'matchPreviousExpr'</span><span class="s3">, </span><span class="s2">'matchPreviousLiteral'</span><span class="s3">,</span>
231  <a name="l211"><span class="ln">211  </span></a>           <span class="s2">'nestedExpr'</span><span class="s3">, </span><span class="s2">'nullDebugAction'</span><span class="s3">, </span><span class="s2">'nums'</span><span class="s3">, </span><span class="s2">'oneOf'</span><span class="s3">, </span><span class="s2">'opAssoc'</span><span class="s3">, </span><span class="s2">'operatorPrecedence'</span><span class="s3">, </span><span class="s2">'printables'</span><span class="s3">,</span>
232  <a name="l212"><span class="ln">212  </span></a>           <span class="s2">'punc8bit'</span><span class="s3">, </span><span class="s2">'pythonStyleComment'</span><span class="s3">, </span><span class="s2">'quotedString'</span><span class="s3">, </span><span class="s2">'removeQuotes'</span><span class="s3">, </span><span class="s2">'replaceHTMLEntity'</span><span class="s3">,</span>
233  <a name="l213"><span class="ln">213  </span></a>           <span class="s2">'replaceWith'</span><span class="s3">, </span><span class="s2">'restOfLine'</span><span class="s3">, </span><span class="s2">'sglQuotedString'</span><span class="s3">, </span><span class="s2">'srange'</span><span class="s3">, </span><span class="s2">'stringEnd'</span><span class="s3">,</span>
234  <a name="l214"><span class="ln">214  </span></a>           <span class="s2">'stringStart'</span><span class="s3">, </span><span class="s2">'traceParseAction'</span><span class="s3">, </span><span class="s2">'unicodeString'</span><span class="s3">, </span><span class="s2">'upcaseTokens'</span><span class="s3">, </span><span class="s2">'withAttribute'</span><span class="s3">,</span>
235  <a name="l215"><span class="ln">215  </span></a>           <span class="s2">'indentedBlock'</span><span class="s3">, </span><span class="s2">'originalTextFor'</span><span class="s3">, </span><span class="s2">'ungroup'</span><span class="s3">, </span><span class="s2">'infixNotation'</span><span class="s3">, </span><span class="s2">'locatedExpr'</span><span class="s3">, </span><span class="s2">'withClass'</span><span class="s3">,</span>
236  <a name="l216"><span class="ln">216  </span></a>           <span class="s2">'CloseMatch'</span><span class="s3">, </span><span class="s2">'tokenMap'</span><span class="s3">, </span><span class="s2">'pyparsing_common'</span><span class="s3">, </span><span class="s2">'pyparsing_unicode'</span><span class="s3">, </span><span class="s2">'unicode_set'</span><span class="s3">,</span>
237  <a name="l217"><span class="ln">217  </span></a>           <span class="s2">'conditionAsParseAction'</span><span class="s3">, </span><span class="s2">'re'</span><span class="s3">,</span>
238  <a name="l218"><span class="ln">218  </span></a>           <span class="s1">]</span>
239  <a name="l219"><span class="ln">219  </span></a>
240  <a name="l220"><span class="ln">220  </span></a><span class="s1">system_version = tuple(sys.version_info)[:</span><span class="s4">3</span><span class="s1">]</span>
241  <a name="l221"><span class="ln">221  </span></a><span class="s1">PY_3 = system_version[</span><span class="s4">0</span><span class="s1">] == </span><span class="s4">3</span>
242  <a name="l222"><span class="ln">222  </span></a><span class="s3">if </span><span class="s1">PY_3:</span>
243  <a name="l223"><span class="ln">223  </span></a>    <span class="s1">_MAX_INT = sys.maxsize</span>
244  <a name="l224"><span class="ln">224  </span></a>    <span class="s1">basestring = str</span>
245  <a name="l225"><span class="ln">225  </span></a>    <span class="s1">unichr = chr</span>
246  <a name="l226"><span class="ln">226  </span></a>    <span class="s1">unicode = str</span>
247  <a name="l227"><span class="ln">227  </span></a>    <span class="s1">_ustr = str</span>
248  <a name="l228"><span class="ln">228  </span></a>
249  <a name="l229"><span class="ln">229  </span></a>    <span class="s0"># build list of single arg builtins, that can be used as parse actions</span>
250  <a name="l230"><span class="ln">230  </span></a>    <span class="s1">singleArgBuiltins = [sum</span><span class="s3">, </span><span class="s1">len</span><span class="s3">, </span><span class="s1">sorted</span><span class="s3">, </span><span class="s1">reversed</span><span class="s3">, </span><span class="s1">list</span><span class="s3">, </span><span class="s1">tuple</span><span class="s3">, </span><span class="s1">set</span><span class="s3">, </span><span class="s1">any</span><span class="s3">, </span><span class="s1">all</span><span class="s3">, </span><span class="s1">min</span><span class="s3">, </span><span class="s1">max]</span>
251  <a name="l231"><span class="ln">231  </span></a>
252  <a name="l232"><span class="ln">232  </span></a><span class="s3">else</span><span class="s1">:</span>
253  <a name="l233"><span class="ln">233  </span></a>    <span class="s1">_MAX_INT = sys.maxint</span>
254  <a name="l234"><span class="ln">234  </span></a>    <span class="s1">range = xrange</span>
255  <a name="l235"><span class="ln">235  </span></a>
256  <a name="l236"><span class="ln">236  </span></a>    <span class="s3">def </span><span class="s1">_ustr(obj):</span>
257  <a name="l237"><span class="ln">237  </span></a>        <span class="s5">&quot;&quot;&quot;Drop-in replacement for str(obj) that tries to be Unicode 
258  <a name="l238"><span class="ln">238  </span></a>        friendly. It first tries str(obj). If that fails with 
259  <a name="l239"><span class="ln">239  </span></a>        a UnicodeEncodeError, then it tries unicode(obj). It then 
260  <a name="l240"><span class="ln">240  </span></a>        &lt; returns the unicode object | encodes it with the default 
261  <a name="l241"><span class="ln">241  </span></a>        encoding | ... &gt;. 
262  <a name="l242"><span class="ln">242  </span></a>        &quot;&quot;&quot;</span>
263  <a name="l243"><span class="ln">243  </span></a>        <span class="s3">if </span><span class="s1">isinstance(obj</span><span class="s3">, </span><span class="s1">unicode):</span>
264  <a name="l244"><span class="ln">244  </span></a>            <span class="s3">return </span><span class="s1">obj</span>
265  <a name="l245"><span class="ln">245  </span></a>
266  <a name="l246"><span class="ln">246  </span></a>        <span class="s3">try</span><span class="s1">:</span>
267  <a name="l247"><span class="ln">247  </span></a>            <span class="s0"># If this works, then _ustr(obj) has the same behaviour as str(obj), so</span>
268  <a name="l248"><span class="ln">248  </span></a>            <span class="s0"># it won't break any existing code.</span>
269  <a name="l249"><span class="ln">249  </span></a>            <span class="s3">return </span><span class="s1">str(obj)</span>
270  <a name="l250"><span class="ln">250  </span></a>
271  <a name="l251"><span class="ln">251  </span></a>        <span class="s3">except </span><span class="s1">UnicodeEncodeError:</span>
272  <a name="l252"><span class="ln">252  </span></a>            <span class="s0"># Else encode it</span>
273  <a name="l253"><span class="ln">253  </span></a>            <span class="s1">ret = unicode(obj).encode(sys.getdefaultencoding()</span><span class="s3">, </span><span class="s2">'xmlcharrefreplace'</span><span class="s1">)</span>
274  <a name="l254"><span class="ln">254  </span></a>            <span class="s1">xmlcharref = Regex(</span><span class="s2">r'&amp;#\d+;'</span><span class="s1">)</span>
275  <a name="l255"><span class="ln">255  </span></a>            <span class="s1">xmlcharref.setParseAction(</span><span class="s3">lambda </span><span class="s1">t: </span><span class="s2">'</span><span class="s3">\\</span><span class="s2">u' </span><span class="s1">+ hex(int(t[</span><span class="s4">0</span><span class="s1">][</span><span class="s4">2</span><span class="s1">:-</span><span class="s4">1</span><span class="s1">]))[</span><span class="s4">2</span><span class="s1">:])</span>
276  <a name="l256"><span class="ln">256  </span></a>            <span class="s3">return </span><span class="s1">xmlcharref.transformString(ret)</span>
277  <a name="l257"><span class="ln">257  </span></a>
278  <a name="l258"><span class="ln">258  </span></a>    <span class="s0"># build list of single arg builtins, tolerant of Python version, that can be used as parse actions</span>
279  <a name="l259"><span class="ln">259  </span></a>    <span class="s1">singleArgBuiltins = []</span>
280  <a name="l260"><span class="ln">260  </span></a>    <span class="s3">import </span><span class="s1">__builtin__</span>
281  <a name="l261"><span class="ln">261  </span></a>
282  <a name="l262"><span class="ln">262  </span></a>    <span class="s3">for </span><span class="s1">fname </span><span class="s3">in </span><span class="s2">&quot;sum len sorted reversed list tuple set any all min max&quot;</span><span class="s1">.split():</span>
283  <a name="l263"><span class="ln">263  </span></a>        <span class="s3">try</span><span class="s1">:</span>
284  <a name="l264"><span class="ln">264  </span></a>            <span class="s1">singleArgBuiltins.append(getattr(__builtin__</span><span class="s3">, </span><span class="s1">fname))</span>
285  <a name="l265"><span class="ln">265  </span></a>        <span class="s3">except </span><span class="s1">AttributeError:</span>
286  <a name="l266"><span class="ln">266  </span></a>            <span class="s3">continue</span>
287  <a name="l267"><span class="ln">267  </span></a>
288  <a name="l268"><span class="ln">268  </span></a><span class="s1">_generatorType = type((y </span><span class="s3">for </span><span class="s1">y </span><span class="s3">in </span><span class="s1">range(</span><span class="s4">1</span><span class="s1">)))</span>
289  <a name="l269"><span class="ln">269  </span></a>
290  <a name="l270"><span class="ln">270  </span></a><span class="s3">def </span><span class="s1">_xml_escape(data):</span>
291  <a name="l271"><span class="ln">271  </span></a>    <span class="s5">&quot;&quot;&quot;Escape &amp;, &lt;, &gt;, &quot;, ', etc. in a string of data.&quot;&quot;&quot;</span>
292  <a name="l272"><span class="ln">272  </span></a>
293  <a name="l273"><span class="ln">273  </span></a>    <span class="s0"># ampersand must be replaced first</span>
294  <a name="l274"><span class="ln">274  </span></a>    <span class="s1">from_symbols = </span><span class="s2">'&amp;&gt;&lt;&quot;</span><span class="s3">\'</span><span class="s2">'</span>
295  <a name="l275"><span class="ln">275  </span></a>    <span class="s1">to_symbols = (</span><span class="s2">'&amp;' </span><span class="s1">+ s + </span><span class="s2">';' </span><span class="s3">for </span><span class="s1">s </span><span class="s3">in </span><span class="s2">&quot;amp gt lt quot apos&quot;</span><span class="s1">.split())</span>
296  <a name="l276"><span class="ln">276  </span></a>    <span class="s3">for </span><span class="s1">from_</span><span class="s3">, </span><span class="s1">to_ </span><span class="s3">in </span><span class="s1">zip(from_symbols</span><span class="s3">, </span><span class="s1">to_symbols):</span>
297  <a name="l277"><span class="ln">277  </span></a>        <span class="s1">data = data.replace(from_</span><span class="s3">, </span><span class="s1">to_)</span>
298  <a name="l278"><span class="ln">278  </span></a>    <span class="s3">return </span><span class="s1">data</span>
299  <a name="l279"><span class="ln">279  </span></a>
300  <a name="l280"><span class="ln">280  </span></a><span class="s1">alphas = string.ascii_uppercase + string.ascii_lowercase</span>
301  <a name="l281"><span class="ln">281  </span></a><span class="s1">nums = </span><span class="s2">&quot;0123456789&quot;</span>
302  <a name="l282"><span class="ln">282  </span></a><span class="s1">hexnums = nums + </span><span class="s2">&quot;ABCDEFabcdef&quot;</span>
303  <a name="l283"><span class="ln">283  </span></a><span class="s1">alphanums = alphas + nums</span>
304  <a name="l284"><span class="ln">284  </span></a><span class="s1">_bslash = chr(</span><span class="s4">92</span><span class="s1">)</span>
305  <a name="l285"><span class="ln">285  </span></a><span class="s1">printables = </span><span class="s2">&quot;&quot;</span><span class="s1">.join(c </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">string.printable </span><span class="s3">if </span><span class="s1">c </span><span class="s3">not in </span><span class="s1">string.whitespace)</span>
306  <a name="l286"><span class="ln">286  </span></a>
307  <a name="l287"><span class="ln">287  </span></a>
308  <a name="l288"><span class="ln">288  </span></a><span class="s3">def </span><span class="s1">conditionAsParseAction(fn</span><span class="s3">, </span><span class="s1">message=</span><span class="s3">None, </span><span class="s1">fatal=</span><span class="s3">False</span><span class="s1">):</span>
309  <a name="l289"><span class="ln">289  </span></a>    <span class="s1">msg = message </span><span class="s3">if </span><span class="s1">message </span><span class="s3">is not None else </span><span class="s2">&quot;failed user-defined condition&quot;</span>
310  <a name="l290"><span class="ln">290  </span></a>    <span class="s1">exc_type = ParseFatalException </span><span class="s3">if </span><span class="s1">fatal </span><span class="s3">else </span><span class="s1">ParseException</span>
311  <a name="l291"><span class="ln">291  </span></a>    <span class="s1">fn = _trim_arity(fn)</span>
312  <a name="l292"><span class="ln">292  </span></a>
313  <a name="l293"><span class="ln">293  </span></a>    <span class="s1">@wraps(fn)</span>
314  <a name="l294"><span class="ln">294  </span></a>    <span class="s3">def </span><span class="s1">pa(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
315  <a name="l295"><span class="ln">295  </span></a>        <span class="s3">if not </span><span class="s1">bool(fn(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t)):</span>
316  <a name="l296"><span class="ln">296  </span></a>            <span class="s3">raise </span><span class="s1">exc_type(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">msg)</span>
317  <a name="l297"><span class="ln">297  </span></a>
318  <a name="l298"><span class="ln">298  </span></a>    <span class="s3">return </span><span class="s1">pa</span>
319  <a name="l299"><span class="ln">299  </span></a>
320  <a name="l300"><span class="ln">300  </span></a><span class="s3">class </span><span class="s1">ParseBaseException(Exception):</span>
321  <a name="l301"><span class="ln">301  </span></a>    <span class="s5">&quot;&quot;&quot;base exception class for all parsing runtime exceptions&quot;&quot;&quot;</span>
322  <a name="l302"><span class="ln">302  </span></a>    <span class="s0"># Performance tuning: we construct a *lot* of these, so keep this</span>
323  <a name="l303"><span class="ln">303  </span></a>    <span class="s0"># constructor as small and fast as possible</span>
324  <a name="l304"><span class="ln">304  </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">pstr</span><span class="s3">, </span><span class="s1">loc=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">msg=</span><span class="s3">None, </span><span class="s1">elem=</span><span class="s3">None</span><span class="s1">):</span>
325  <a name="l305"><span class="ln">305  </span></a>        <span class="s1">self.loc = loc</span>
326  <a name="l306"><span class="ln">306  </span></a>        <span class="s3">if </span><span class="s1">msg </span><span class="s3">is None</span><span class="s1">:</span>
327  <a name="l307"><span class="ln">307  </span></a>            <span class="s1">self.msg = pstr</span>
328  <a name="l308"><span class="ln">308  </span></a>            <span class="s1">self.pstr = </span><span class="s2">&quot;&quot;</span>
329  <a name="l309"><span class="ln">309  </span></a>        <span class="s3">else</span><span class="s1">:</span>
330  <a name="l310"><span class="ln">310  </span></a>            <span class="s1">self.msg = msg</span>
331  <a name="l311"><span class="ln">311  </span></a>            <span class="s1">self.pstr = pstr</span>
332  <a name="l312"><span class="ln">312  </span></a>        <span class="s1">self.parserElement = elem</span>
333  <a name="l313"><span class="ln">313  </span></a>        <span class="s1">self.args = (pstr</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">msg)</span>
334  <a name="l314"><span class="ln">314  </span></a>
335  <a name="l315"><span class="ln">315  </span></a>    <span class="s1">@classmethod</span>
336  <a name="l316"><span class="ln">316  </span></a>    <span class="s3">def </span><span class="s1">_from_exception(cls</span><span class="s3">, </span><span class="s1">pe):</span>
337  <a name="l317"><span class="ln">317  </span></a>        <span class="s5">&quot;&quot;&quot; 
338  <a name="l318"><span class="ln">318  </span></a>        internal factory method to simplify creating one type of ParseException 
339  <a name="l319"><span class="ln">319  </span></a>        from another - avoids having __init__ signature conflicts among subclasses 
340  <a name="l320"><span class="ln">320  </span></a>        &quot;&quot;&quot;</span>
341  <a name="l321"><span class="ln">321  </span></a>        <span class="s3">return </span><span class="s1">cls(pe.pstr</span><span class="s3">, </span><span class="s1">pe.loc</span><span class="s3">, </span><span class="s1">pe.msg</span><span class="s3">, </span><span class="s1">pe.parserElement)</span>
342  <a name="l322"><span class="ln">322  </span></a>
343  <a name="l323"><span class="ln">323  </span></a>    <span class="s3">def </span><span class="s1">__getattr__(self</span><span class="s3">, </span><span class="s1">aname):</span>
344  <a name="l324"><span class="ln">324  </span></a>        <span class="s5">&quot;&quot;&quot;supported attributes by name are: 
345  <a name="l325"><span class="ln">325  </span></a>           - lineno - returns the line number of the exception text 
346  <a name="l326"><span class="ln">326  </span></a>           - col - returns the column number of the exception text 
347  <a name="l327"><span class="ln">327  </span></a>           - line - returns the line containing the exception text 
348  <a name="l328"><span class="ln">328  </span></a>        &quot;&quot;&quot;</span>
349  <a name="l329"><span class="ln">329  </span></a>        <span class="s3">if </span><span class="s1">aname == </span><span class="s2">&quot;lineno&quot;</span><span class="s1">:</span>
350  <a name="l330"><span class="ln">330  </span></a>            <span class="s3">return </span><span class="s1">lineno(self.loc</span><span class="s3">, </span><span class="s1">self.pstr)</span>
351  <a name="l331"><span class="ln">331  </span></a>        <span class="s3">elif </span><span class="s1">aname </span><span class="s3">in </span><span class="s1">(</span><span class="s2">&quot;col&quot;</span><span class="s3">, </span><span class="s2">&quot;column&quot;</span><span class="s1">):</span>
352  <a name="l332"><span class="ln">332  </span></a>            <span class="s3">return </span><span class="s1">col(self.loc</span><span class="s3">, </span><span class="s1">self.pstr)</span>
353  <a name="l333"><span class="ln">333  </span></a>        <span class="s3">elif </span><span class="s1">aname == </span><span class="s2">&quot;line&quot;</span><span class="s1">:</span>
354  <a name="l334"><span class="ln">334  </span></a>            <span class="s3">return </span><span class="s1">line(self.loc</span><span class="s3">, </span><span class="s1">self.pstr)</span>
355  <a name="l335"><span class="ln">335  </span></a>        <span class="s3">else</span><span class="s1">:</span>
356  <a name="l336"><span class="ln">336  </span></a>            <span class="s3">raise </span><span class="s1">AttributeError(aname)</span>
357  <a name="l337"><span class="ln">337  </span></a>
358  <a name="l338"><span class="ln">338  </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
359  <a name="l339"><span class="ln">339  </span></a>        <span class="s3">if </span><span class="s1">self.pstr:</span>
360  <a name="l340"><span class="ln">340  </span></a>            <span class="s3">if </span><span class="s1">self.loc &gt;= len(self.pstr):</span>
361  <a name="l341"><span class="ln">341  </span></a>                <span class="s1">foundstr = </span><span class="s2">', found end of text'</span>
362  <a name="l342"><span class="ln">342  </span></a>            <span class="s3">else</span><span class="s1">:</span>
363  <a name="l343"><span class="ln">343  </span></a>                <span class="s1">foundstr = (</span><span class="s2">', found %r' </span><span class="s1">% self.pstr[self.loc:self.loc + </span><span class="s4">1</span><span class="s1">]).replace(</span><span class="s2">r'\\'</span><span class="s3">, </span><span class="s2">'</span><span class="s3">\\</span><span class="s2">'</span><span class="s1">)</span>
364  <a name="l344"><span class="ln">344  </span></a>        <span class="s3">else</span><span class="s1">:</span>
365  <a name="l345"><span class="ln">345  </span></a>            <span class="s1">foundstr = </span><span class="s2">''</span>
366  <a name="l346"><span class="ln">346  </span></a>        <span class="s3">return </span><span class="s1">(</span><span class="s2">&quot;%s%s  (at char %d), (line:%d, col:%d)&quot; </span><span class="s1">%</span>
367  <a name="l347"><span class="ln">347  </span></a>                   <span class="s1">(self.msg</span><span class="s3">, </span><span class="s1">foundstr</span><span class="s3">, </span><span class="s1">self.loc</span><span class="s3">, </span><span class="s1">self.lineno</span><span class="s3">, </span><span class="s1">self.column))</span>
368  <a name="l348"><span class="ln">348  </span></a>    <span class="s3">def </span><span class="s1">__repr__(self):</span>
369  <a name="l349"><span class="ln">349  </span></a>        <span class="s3">return </span><span class="s1">_ustr(self)</span>
370  <a name="l350"><span class="ln">350  </span></a>    <span class="s3">def </span><span class="s1">markInputline(self</span><span class="s3">, </span><span class="s1">markerString=</span><span class="s2">&quot;&gt;!&lt;&quot;</span><span class="s1">):</span>
371  <a name="l351"><span class="ln">351  </span></a>        <span class="s5">&quot;&quot;&quot;Extracts the exception line from the input string, and marks 
372  <a name="l352"><span class="ln">352  </span></a>           the location of the exception with a special symbol. 
373  <a name="l353"><span class="ln">353  </span></a>        &quot;&quot;&quot;</span>
374  <a name="l354"><span class="ln">354  </span></a>        <span class="s1">line_str = self.line</span>
375  <a name="l355"><span class="ln">355  </span></a>        <span class="s1">line_column = self.column - </span><span class="s4">1</span>
376  <a name="l356"><span class="ln">356  </span></a>        <span class="s3">if </span><span class="s1">markerString:</span>
377  <a name="l357"><span class="ln">357  </span></a>            <span class="s1">line_str = </span><span class="s2">&quot;&quot;</span><span class="s1">.join((line_str[:line_column]</span><span class="s3">,</span>
378  <a name="l358"><span class="ln">358  </span></a>                                <span class="s1">markerString</span><span class="s3">, </span><span class="s1">line_str[line_column:]))</span>
379  <a name="l359"><span class="ln">359  </span></a>        <span class="s3">return </span><span class="s1">line_str.strip()</span>
380  <a name="l360"><span class="ln">360  </span></a>    <span class="s3">def </span><span class="s1">__dir__(self):</span>
381  <a name="l361"><span class="ln">361  </span></a>        <span class="s3">return </span><span class="s2">&quot;lineno col line&quot;</span><span class="s1">.split() + dir(type(self))</span>
382  <a name="l362"><span class="ln">362  </span></a>
383  <a name="l363"><span class="ln">363  </span></a><span class="s3">class </span><span class="s1">ParseException(ParseBaseException):</span>
384  <a name="l364"><span class="ln">364  </span></a>    <span class="s5">&quot;&quot;&quot; 
385  <a name="l365"><span class="ln">365  </span></a>    Exception thrown when parse expressions don't match class; 
386  <a name="l366"><span class="ln">366  </span></a>    supported attributes by name are: 
387  <a name="l367"><span class="ln">367  </span></a>    - lineno - returns the line number of the exception text 
388  <a name="l368"><span class="ln">368  </span></a>    - col - returns the column number of the exception text 
389  <a name="l369"><span class="ln">369  </span></a>    - line - returns the line containing the exception text 
390  <a name="l370"><span class="ln">370  </span></a> 
391  <a name="l371"><span class="ln">371  </span></a>    Example:: 
392  <a name="l372"><span class="ln">372  </span></a> 
393  <a name="l373"><span class="ln">373  </span></a>        try: 
394  <a name="l374"><span class="ln">374  </span></a>            Word(nums).setName(&quot;integer&quot;).parseString(&quot;ABC&quot;) 
395  <a name="l375"><span class="ln">375  </span></a>        except ParseException as pe: 
396  <a name="l376"><span class="ln">376  </span></a>            print(pe) 
397  <a name="l377"><span class="ln">377  </span></a>            print(&quot;column: {}&quot;.format(pe.col)) 
398  <a name="l378"><span class="ln">378  </span></a> 
399  <a name="l379"><span class="ln">379  </span></a>    prints:: 
400  <a name="l380"><span class="ln">380  </span></a> 
401  <a name="l381"><span class="ln">381  </span></a>       Expected integer (at char 0), (line:1, col:1) 
402  <a name="l382"><span class="ln">382  </span></a>        column: 1 
403  <a name="l383"><span class="ln">383  </span></a> 
404  <a name="l384"><span class="ln">384  </span></a>    &quot;&quot;&quot;</span>
405  <a name="l385"><span class="ln">385  </span></a>
406  <a name="l386"><span class="ln">386  </span></a>    <span class="s1">@staticmethod</span>
407  <a name="l387"><span class="ln">387  </span></a>    <span class="s3">def </span><span class="s1">explain(exc</span><span class="s3">, </span><span class="s1">depth=</span><span class="s4">16</span><span class="s1">):</span>
408  <a name="l388"><span class="ln">388  </span></a>        <span class="s5">&quot;&quot;&quot; 
409  <a name="l389"><span class="ln">389  </span></a>        Method to take an exception and translate the Python internal traceback into a list 
410  <a name="l390"><span class="ln">390  </span></a>        of the pyparsing expressions that caused the exception to be raised. 
411  <a name="l391"><span class="ln">391  </span></a> 
412  <a name="l392"><span class="ln">392  </span></a>        Parameters: 
413  <a name="l393"><span class="ln">393  </span></a> 
414  <a name="l394"><span class="ln">394  </span></a>         - exc - exception raised during parsing (need not be a ParseException, in support 
415  <a name="l395"><span class="ln">395  </span></a>           of Python exceptions that might be raised in a parse action) 
416  <a name="l396"><span class="ln">396  </span></a>         - depth (default=16) - number of levels back in the stack trace to list expression 
417  <a name="l397"><span class="ln">397  </span></a>           and function names; if None, the full stack trace names will be listed; if 0, only 
418  <a name="l398"><span class="ln">398  </span></a>           the failing input line, marker, and exception string will be shown 
419  <a name="l399"><span class="ln">399  </span></a> 
420  <a name="l400"><span class="ln">400  </span></a>        Returns a multi-line string listing the ParserElements and/or function names in the 
421  <a name="l401"><span class="ln">401  </span></a>        exception's stack trace. 
422  <a name="l402"><span class="ln">402  </span></a> 
423  <a name="l403"><span class="ln">403  </span></a>        Note: the diagnostic output will include string representations of the expressions 
424  <a name="l404"><span class="ln">404  </span></a>        that failed to parse. These representations will be more helpful if you use `setName` to 
425  <a name="l405"><span class="ln">405  </span></a>        give identifiable names to your expressions. Otherwise they will use the default string 
426  <a name="l406"><span class="ln">406  </span></a>        forms, which may be cryptic to read. 
427  <a name="l407"><span class="ln">407  </span></a> 
428  <a name="l408"><span class="ln">408  </span></a>        explain() is only supported under Python 3. 
429  <a name="l409"><span class="ln">409  </span></a>        &quot;&quot;&quot;</span>
430  <a name="l410"><span class="ln">410  </span></a>        <span class="s3">import </span><span class="s1">inspect</span>
431  <a name="l411"><span class="ln">411  </span></a>
432  <a name="l412"><span class="ln">412  </span></a>        <span class="s3">if </span><span class="s1">depth </span><span class="s3">is None</span><span class="s1">:</span>
433  <a name="l413"><span class="ln">413  </span></a>            <span class="s1">depth = sys.getrecursionlimit()</span>
434  <a name="l414"><span class="ln">414  </span></a>        <span class="s1">ret = []</span>
435  <a name="l415"><span class="ln">415  </span></a>        <span class="s3">if </span><span class="s1">isinstance(exc</span><span class="s3">, </span><span class="s1">ParseBaseException):</span>
436  <a name="l416"><span class="ln">416  </span></a>            <span class="s1">ret.append(exc.line)</span>
437  <a name="l417"><span class="ln">417  </span></a>            <span class="s1">ret.append(</span><span class="s2">' ' </span><span class="s1">* (exc.col - </span><span class="s4">1</span><span class="s1">) + </span><span class="s2">'^'</span><span class="s1">)</span>
438  <a name="l418"><span class="ln">418  </span></a>        <span class="s1">ret.append(</span><span class="s2">&quot;{0}: {1}&quot;</span><span class="s1">.format(type(exc).__name__</span><span class="s3">, </span><span class="s1">exc))</span>
439  <a name="l419"><span class="ln">419  </span></a>
440  <a name="l420"><span class="ln">420  </span></a>        <span class="s3">if </span><span class="s1">depth &gt; </span><span class="s4">0</span><span class="s1">:</span>
441  <a name="l421"><span class="ln">421  </span></a>            <span class="s1">callers = inspect.getinnerframes(exc.__traceback__</span><span class="s3">, </span><span class="s1">context=depth)</span>
442  <a name="l422"><span class="ln">422  </span></a>            <span class="s1">seen = set()</span>
443  <a name="l423"><span class="ln">423  </span></a>            <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">ff </span><span class="s3">in </span><span class="s1">enumerate(callers[-depth:]):</span>
444  <a name="l424"><span class="ln">424  </span></a>                <span class="s1">frm = ff[</span><span class="s4">0</span><span class="s1">]</span>
445  <a name="l425"><span class="ln">425  </span></a>
446  <a name="l426"><span class="ln">426  </span></a>                <span class="s1">f_self = frm.f_locals.get(</span><span class="s2">'self'</span><span class="s3">, None</span><span class="s1">)</span>
447  <a name="l427"><span class="ln">427  </span></a>                <span class="s3">if </span><span class="s1">isinstance(f_self</span><span class="s3">, </span><span class="s1">ParserElement):</span>
448  <a name="l428"><span class="ln">428  </span></a>                    <span class="s3">if </span><span class="s1">frm.f_code.co_name </span><span class="s3">not in </span><span class="s1">(</span><span class="s2">'parseImpl'</span><span class="s3">, </span><span class="s2">'_parseNoCache'</span><span class="s1">):</span>
449  <a name="l429"><span class="ln">429  </span></a>                        <span class="s3">continue</span>
450  <a name="l430"><span class="ln">430  </span></a>                    <span class="s3">if </span><span class="s1">f_self </span><span class="s3">in </span><span class="s1">seen:</span>
451  <a name="l431"><span class="ln">431  </span></a>                        <span class="s3">continue</span>
452  <a name="l432"><span class="ln">432  </span></a>                    <span class="s1">seen.add(f_self)</span>
453  <a name="l433"><span class="ln">433  </span></a>
454  <a name="l434"><span class="ln">434  </span></a>                    <span class="s1">self_type = type(f_self)</span>
455  <a name="l435"><span class="ln">435  </span></a>                    <span class="s1">ret.append(</span><span class="s2">&quot;{0}.{1} - {2}&quot;</span><span class="s1">.format(self_type.__module__</span><span class="s3">,</span>
456  <a name="l436"><span class="ln">436  </span></a>                                                      <span class="s1">self_type.__name__</span><span class="s3">,</span>
457  <a name="l437"><span class="ln">437  </span></a>                                                      <span class="s1">f_self))</span>
458  <a name="l438"><span class="ln">438  </span></a>                <span class="s3">elif </span><span class="s1">f_self </span><span class="s3">is not None</span><span class="s1">:</span>
459  <a name="l439"><span class="ln">439  </span></a>                    <span class="s1">self_type = type(f_self)</span>
460  <a name="l440"><span class="ln">440  </span></a>                    <span class="s1">ret.append(</span><span class="s2">&quot;{0}.{1}&quot;</span><span class="s1">.format(self_type.__module__</span><span class="s3">,</span>
461  <a name="l441"><span class="ln">441  </span></a>                                                <span class="s1">self_type.__name__))</span>
462  <a name="l442"><span class="ln">442  </span></a>                <span class="s3">else</span><span class="s1">:</span>
463  <a name="l443"><span class="ln">443  </span></a>                    <span class="s1">code = frm.f_code</span>
464  <a name="l444"><span class="ln">444  </span></a>                    <span class="s3">if </span><span class="s1">code.co_name </span><span class="s3">in </span><span class="s1">(</span><span class="s2">'wrapper'</span><span class="s3">, </span><span class="s2">'&lt;module&gt;'</span><span class="s1">):</span>
465  <a name="l445"><span class="ln">445  </span></a>                        <span class="s3">continue</span>
466  <a name="l446"><span class="ln">446  </span></a>
467  <a name="l447"><span class="ln">447  </span></a>                    <span class="s1">ret.append(</span><span class="s2">&quot;{0}&quot;</span><span class="s1">.format(code.co_name))</span>
468  <a name="l448"><span class="ln">448  </span></a>
469  <a name="l449"><span class="ln">449  </span></a>                <span class="s1">depth -= </span><span class="s4">1</span>
470  <a name="l450"><span class="ln">450  </span></a>                <span class="s3">if not </span><span class="s1">depth:</span>
471  <a name="l451"><span class="ln">451  </span></a>                    <span class="s3">break</span>
472  <a name="l452"><span class="ln">452  </span></a>
473  <a name="l453"><span class="ln">453  </span></a>        <span class="s3">return </span><span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span><span class="s1">.join(ret)</span>
474  <a name="l454"><span class="ln">454  </span></a>
475  <a name="l455"><span class="ln">455  </span></a>
476  <a name="l456"><span class="ln">456  </span></a><span class="s3">class </span><span class="s1">ParseFatalException(ParseBaseException):</span>
477  <a name="l457"><span class="ln">457  </span></a>    <span class="s5">&quot;&quot;&quot;user-throwable exception thrown when inconsistent parse content 
478  <a name="l458"><span class="ln">458  </span></a>       is found; stops all parsing immediately&quot;&quot;&quot;</span>
479  <a name="l459"><span class="ln">459  </span></a>    <span class="s3">pass</span>
480  <a name="l460"><span class="ln">460  </span></a>
481  <a name="l461"><span class="ln">461  </span></a><span class="s3">class </span><span class="s1">ParseSyntaxException(ParseFatalException):</span>
482  <a name="l462"><span class="ln">462  </span></a>    <span class="s5">&quot;&quot;&quot;just like :class:`ParseFatalException`, but thrown internally 
483  <a name="l463"><span class="ln">463  </span></a>    when an :class:`ErrorStop&lt;And._ErrorStop&gt;` ('-' operator) indicates 
484  <a name="l464"><span class="ln">464  </span></a>    that parsing is to stop immediately because an unbacktrackable 
485  <a name="l465"><span class="ln">465  </span></a>    syntax error has been found. 
486  <a name="l466"><span class="ln">466  </span></a>    &quot;&quot;&quot;</span>
487  <a name="l467"><span class="ln">467  </span></a>    <span class="s3">pass</span>
488  <a name="l468"><span class="ln">468  </span></a>
489  <a name="l469"><span class="ln">469  </span></a><span class="s0">#~ class ReparseException(ParseBaseException):</span>
490  <a name="l470"><span class="ln">470  </span></a>    <span class="s0">#~ &quot;&quot;&quot;Experimental class - parse actions can raise this exception to cause</span>
491  <a name="l471"><span class="ln">471  </span></a>       <span class="s0">#~ pyparsing to reparse the input string:</span>
492  <a name="l472"><span class="ln">472  </span></a>        <span class="s0">#~ - with a modified input string, and/or</span>
493  <a name="l473"><span class="ln">473  </span></a>        <span class="s0">#~ - with a modified start location</span>
494  <a name="l474"><span class="ln">474  </span></a>       <span class="s0">#~ Set the values of the ReparseException in the constructor, and raise the</span>
495  <a name="l475"><span class="ln">475  </span></a>       <span class="s0">#~ exception in a parse action to cause pyparsing to use the new string/location.</span>
496  <a name="l476"><span class="ln">476  </span></a>       <span class="s0">#~ Setting the values as None causes no change to be made.</span>
497  <a name="l477"><span class="ln">477  </span></a>       <span class="s0">#~ &quot;&quot;&quot;</span>
498  <a name="l478"><span class="ln">478  </span></a>    <span class="s0">#~ def __init_( self, newstring, restartLoc ):</span>
499  <a name="l479"><span class="ln">479  </span></a>        <span class="s0">#~ self.newParseText = newstring</span>
500  <a name="l480"><span class="ln">480  </span></a>        <span class="s0">#~ self.reparseLoc = restartLoc</span>
501  <a name="l481"><span class="ln">481  </span></a>
502  <a name="l482"><span class="ln">482  </span></a><span class="s3">class </span><span class="s1">RecursiveGrammarException(Exception):</span>
503  <a name="l483"><span class="ln">483  </span></a>    <span class="s5">&quot;&quot;&quot;exception thrown by :class:`ParserElement.validate` if the 
504  <a name="l484"><span class="ln">484  </span></a>    grammar could be improperly recursive 
505  <a name="l485"><span class="ln">485  </span></a>    &quot;&quot;&quot;</span>
506  <a name="l486"><span class="ln">486  </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
507  <a name="l487"><span class="ln">487  </span></a>        <span class="s1">self.parseElementTrace = parseElementList</span>
508  <a name="l488"><span class="ln">488  </span></a>
509  <a name="l489"><span class="ln">489  </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
510  <a name="l490"><span class="ln">490  </span></a>        <span class="s3">return </span><span class="s2">&quot;RecursiveGrammarException: %s&quot; </span><span class="s1">% self.parseElementTrace</span>
511  <a name="l491"><span class="ln">491  </span></a>
512  <a name="l492"><span class="ln">492  </span></a><span class="s3">class </span><span class="s1">_ParseResultsWithOffset(object):</span>
513  <a name="l493"><span class="ln">493  </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">p1</span><span class="s3">, </span><span class="s1">p2):</span>
514  <a name="l494"><span class="ln">494  </span></a>        <span class="s1">self.tup = (p1</span><span class="s3">, </span><span class="s1">p2)</span>
515  <a name="l495"><span class="ln">495  </span></a>    <span class="s3">def </span><span class="s1">__getitem__(self</span><span class="s3">, </span><span class="s1">i):</span>
516  <a name="l496"><span class="ln">496  </span></a>        <span class="s3">return </span><span class="s1">self.tup[i]</span>
517  <a name="l497"><span class="ln">497  </span></a>    <span class="s3">def </span><span class="s1">__repr__(self):</span>
518  <a name="l498"><span class="ln">498  </span></a>        <span class="s3">return </span><span class="s1">repr(self.tup[</span><span class="s4">0</span><span class="s1">])</span>
519  <a name="l499"><span class="ln">499  </span></a>    <span class="s3">def </span><span class="s1">setOffset(self</span><span class="s3">, </span><span class="s1">i):</span>
520  <a name="l500"><span class="ln">500  </span></a>        <span class="s1">self.tup = (self.tup[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">i)</span>
521  <a name="l501"><span class="ln">501  </span></a>
522  <a name="l502"><span class="ln">502  </span></a><span class="s3">class </span><span class="s1">ParseResults(object):</span>
523  <a name="l503"><span class="ln">503  </span></a>    <span class="s5">&quot;&quot;&quot;Structured parse results, to provide multiple means of access to 
524  <a name="l504"><span class="ln">504  </span></a>    the parsed data: 
525  <a name="l505"><span class="ln">505  </span></a> 
526  <a name="l506"><span class="ln">506  </span></a>       - as a list (``len(results)``) 
527  <a name="l507"><span class="ln">507  </span></a>       - by list index (``results[0], results[1]``, etc.) 
528  <a name="l508"><span class="ln">508  </span></a>       - by attribute (``results.&lt;resultsName&gt;`` - see :class:`ParserElement.setResultsName`) 
529  <a name="l509"><span class="ln">509  </span></a> 
530  <a name="l510"><span class="ln">510  </span></a>    Example:: 
531  <a name="l511"><span class="ln">511  </span></a> 
532  <a name="l512"><span class="ln">512  </span></a>        integer = Word(nums) 
533  <a name="l513"><span class="ln">513  </span></a>        date_str = (integer.setResultsName(&quot;year&quot;) + '/' 
534  <a name="l514"><span class="ln">514  </span></a>                        + integer.setResultsName(&quot;month&quot;) + '/' 
535  <a name="l515"><span class="ln">515  </span></a>                        + integer.setResultsName(&quot;day&quot;)) 
536  <a name="l516"><span class="ln">516  </span></a>        # equivalent form: 
537  <a name="l517"><span class="ln">517  </span></a>        # date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
538  <a name="l518"><span class="ln">518  </span></a> 
539  <a name="l519"><span class="ln">519  </span></a>        # parseString returns a ParseResults object 
540  <a name="l520"><span class="ln">520  </span></a>        result = date_str.parseString(&quot;1999/12/31&quot;) 
541  <a name="l521"><span class="ln">521  </span></a> 
542  <a name="l522"><span class="ln">522  </span></a>        def test(s, fn=repr): 
543  <a name="l523"><span class="ln">523  </span></a>            print(&quot;%s -&gt; %s&quot; % (s, fn(eval(s)))) 
544  <a name="l524"><span class="ln">524  </span></a>        test(&quot;list(result)&quot;) 
545  <a name="l525"><span class="ln">525  </span></a>        test(&quot;result[0]&quot;) 
546  <a name="l526"><span class="ln">526  </span></a>        test(&quot;result['month']&quot;) 
547  <a name="l527"><span class="ln">527  </span></a>        test(&quot;result.day&quot;) 
548  <a name="l528"><span class="ln">528  </span></a>        test(&quot;'month' in result&quot;) 
549  <a name="l529"><span class="ln">529  </span></a>        test(&quot;'minutes' in result&quot;) 
550  <a name="l530"><span class="ln">530  </span></a>        test(&quot;result.dump()&quot;, str) 
551  <a name="l531"><span class="ln">531  </span></a> 
552  <a name="l532"><span class="ln">532  </span></a>    prints:: 
553  <a name="l533"><span class="ln">533  </span></a> 
554  <a name="l534"><span class="ln">534  </span></a>        list(result) -&gt; ['1999', '/', '12', '/', '31'] 
555  <a name="l535"><span class="ln">535  </span></a>        result[0] -&gt; '1999' 
556  <a name="l536"><span class="ln">536  </span></a>        result['month'] -&gt; '12' 
557  <a name="l537"><span class="ln">537  </span></a>        result.day -&gt; '31' 
558  <a name="l538"><span class="ln">538  </span></a>        'month' in result -&gt; True 
559  <a name="l539"><span class="ln">539  </span></a>        'minutes' in result -&gt; False 
560  <a name="l540"><span class="ln">540  </span></a>        result.dump() -&gt; ['1999', '/', '12', '/', '31'] 
561  <a name="l541"><span class="ln">541  </span></a>        - day: 31 
562  <a name="l542"><span class="ln">542  </span></a>        - month: 12 
563  <a name="l543"><span class="ln">543  </span></a>        - year: 1999 
564  <a name="l544"><span class="ln">544  </span></a>    &quot;&quot;&quot;</span>
565  <a name="l545"><span class="ln">545  </span></a>    <span class="s3">def </span><span class="s1">__new__(cls</span><span class="s3">, </span><span class="s1">toklist=</span><span class="s3">None, </span><span class="s1">name=</span><span class="s3">None, </span><span class="s1">asList=</span><span class="s3">True, </span><span class="s1">modal=</span><span class="s3">True</span><span class="s1">):</span>
566  <a name="l546"><span class="ln">546  </span></a>        <span class="s3">if </span><span class="s1">isinstance(toklist</span><span class="s3">, </span><span class="s1">cls):</span>
567  <a name="l547"><span class="ln">547  </span></a>            <span class="s3">return </span><span class="s1">toklist</span>
568  <a name="l548"><span class="ln">548  </span></a>        <span class="s1">retobj = object.__new__(cls)</span>
569  <a name="l549"><span class="ln">549  </span></a>        <span class="s1">retobj.__doinit = </span><span class="s3">True</span>
570  <a name="l550"><span class="ln">550  </span></a>        <span class="s3">return </span><span class="s1">retobj</span>
571  <a name="l551"><span class="ln">551  </span></a>
572  <a name="l552"><span class="ln">552  </span></a>    <span class="s0"># Performance tuning: we construct a *lot* of these, so keep this</span>
573  <a name="l553"><span class="ln">553  </span></a>    <span class="s0"># constructor as small and fast as possible</span>
574  <a name="l554"><span class="ln">554  </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">toklist=</span><span class="s3">None, </span><span class="s1">name=</span><span class="s3">None, </span><span class="s1">asList=</span><span class="s3">True, </span><span class="s1">modal=</span><span class="s3">True, </span><span class="s1">isinstance=isinstance):</span>
575  <a name="l555"><span class="ln">555  </span></a>        <span class="s3">if </span><span class="s1">self.__doinit:</span>
576  <a name="l556"><span class="ln">556  </span></a>            <span class="s1">self.__doinit = </span><span class="s3">False</span>
577  <a name="l557"><span class="ln">557  </span></a>            <span class="s1">self.__name = </span><span class="s3">None</span>
578  <a name="l558"><span class="ln">558  </span></a>            <span class="s1">self.__parent = </span><span class="s3">None</span>
579  <a name="l559"><span class="ln">559  </span></a>            <span class="s1">self.__accumNames = {}</span>
580  <a name="l560"><span class="ln">560  </span></a>            <span class="s1">self.__asList = asList</span>
581  <a name="l561"><span class="ln">561  </span></a>            <span class="s1">self.__modal = modal</span>
582  <a name="l562"><span class="ln">562  </span></a>            <span class="s3">if </span><span class="s1">toklist </span><span class="s3">is None</span><span class="s1">:</span>
583  <a name="l563"><span class="ln">563  </span></a>                <span class="s1">toklist = []</span>
584  <a name="l564"><span class="ln">564  </span></a>            <span class="s3">if </span><span class="s1">isinstance(toklist</span><span class="s3">, </span><span class="s1">list):</span>
585  <a name="l565"><span class="ln">565  </span></a>                <span class="s1">self.__toklist = toklist[:]</span>
586  <a name="l566"><span class="ln">566  </span></a>            <span class="s3">elif </span><span class="s1">isinstance(toklist</span><span class="s3">, </span><span class="s1">_generatorType):</span>
587  <a name="l567"><span class="ln">567  </span></a>                <span class="s1">self.__toklist = list(toklist)</span>
588  <a name="l568"><span class="ln">568  </span></a>            <span class="s3">else</span><span class="s1">:</span>
589  <a name="l569"><span class="ln">569  </span></a>                <span class="s1">self.__toklist = [toklist]</span>
590  <a name="l570"><span class="ln">570  </span></a>            <span class="s1">self.__tokdict = dict()</span>
591  <a name="l571"><span class="ln">571  </span></a>
592  <a name="l572"><span class="ln">572  </span></a>        <span class="s3">if </span><span class="s1">name </span><span class="s3">is not None and </span><span class="s1">name:</span>
593  <a name="l573"><span class="ln">573  </span></a>            <span class="s3">if not </span><span class="s1">modal:</span>
594  <a name="l574"><span class="ln">574  </span></a>                <span class="s1">self.__accumNames[name] = </span><span class="s4">0</span>
595  <a name="l575"><span class="ln">575  </span></a>            <span class="s3">if </span><span class="s1">isinstance(name</span><span class="s3">, </span><span class="s1">int):</span>
596  <a name="l576"><span class="ln">576  </span></a>                <span class="s1">name = _ustr(name)  </span><span class="s0"># will always return a str, but use _ustr for consistency</span>
597  <a name="l577"><span class="ln">577  </span></a>            <span class="s1">self.__name = name</span>
598  <a name="l578"><span class="ln">578  </span></a>            <span class="s3">if not </span><span class="s1">(isinstance(toklist</span><span class="s3">, </span><span class="s1">(type(</span><span class="s3">None</span><span class="s1">)</span><span class="s3">, </span><span class="s1">basestring</span><span class="s3">, </span><span class="s1">list)) </span><span class="s3">and </span><span class="s1">toklist </span><span class="s3">in </span><span class="s1">(</span><span class="s3">None, </span><span class="s2">''</span><span class="s3">, </span><span class="s1">[])):</span>
599  <a name="l579"><span class="ln">579  </span></a>                <span class="s3">if </span><span class="s1">isinstance(toklist</span><span class="s3">, </span><span class="s1">basestring):</span>
600  <a name="l580"><span class="ln">580  </span></a>                    <span class="s1">toklist = [toklist]</span>
601  <a name="l581"><span class="ln">581  </span></a>                <span class="s3">if </span><span class="s1">asList:</span>
602  <a name="l582"><span class="ln">582  </span></a>                    <span class="s3">if </span><span class="s1">isinstance(toklist</span><span class="s3">, </span><span class="s1">ParseResults):</span>
603  <a name="l583"><span class="ln">583  </span></a>                        <span class="s1">self[name] = _ParseResultsWithOffset(ParseResults(toklist.__toklist)</span><span class="s3">, </span><span class="s4">0</span><span class="s1">)</span>
604  <a name="l584"><span class="ln">584  </span></a>                    <span class="s3">else</span><span class="s1">:</span>
605  <a name="l585"><span class="ln">585  </span></a>                        <span class="s1">self[name] = _ParseResultsWithOffset(ParseResults(toklist[</span><span class="s4">0</span><span class="s1">])</span><span class="s3">, </span><span class="s4">0</span><span class="s1">)</span>
606  <a name="l586"><span class="ln">586  </span></a>                    <span class="s1">self[name].__name = name</span>
607  <a name="l587"><span class="ln">587  </span></a>                <span class="s3">else</span><span class="s1">:</span>
608  <a name="l588"><span class="ln">588  </span></a>                    <span class="s3">try</span><span class="s1">:</span>
609  <a name="l589"><span class="ln">589  </span></a>                        <span class="s1">self[name] = toklist[</span><span class="s4">0</span><span class="s1">]</span>
610  <a name="l590"><span class="ln">590  </span></a>                    <span class="s3">except </span><span class="s1">(KeyError</span><span class="s3">, </span><span class="s1">TypeError</span><span class="s3">, </span><span class="s1">IndexError):</span>
611  <a name="l591"><span class="ln">591  </span></a>                        <span class="s1">self[name] = toklist</span>
612  <a name="l592"><span class="ln">592  </span></a>
613  <a name="l593"><span class="ln">593  </span></a>    <span class="s3">def </span><span class="s1">__getitem__(self</span><span class="s3">, </span><span class="s1">i):</span>
614  <a name="l594"><span class="ln">594  </span></a>        <span class="s3">if </span><span class="s1">isinstance(i</span><span class="s3">, </span><span class="s1">(int</span><span class="s3">, </span><span class="s1">slice)):</span>
615  <a name="l595"><span class="ln">595  </span></a>            <span class="s3">return </span><span class="s1">self.__toklist[i]</span>
616  <a name="l596"><span class="ln">596  </span></a>        <span class="s3">else</span><span class="s1">:</span>
617  <a name="l597"><span class="ln">597  </span></a>            <span class="s3">if </span><span class="s1">i </span><span class="s3">not in </span><span class="s1">self.__accumNames:</span>
618  <a name="l598"><span class="ln">598  </span></a>                <span class="s3">return </span><span class="s1">self.__tokdict[i][-</span><span class="s4">1</span><span class="s1">][</span><span class="s4">0</span><span class="s1">]</span>
619  <a name="l599"><span class="ln">599  </span></a>            <span class="s3">else</span><span class="s1">:</span>
620  <a name="l600"><span class="ln">600  </span></a>                <span class="s3">return </span><span class="s1">ParseResults([v[</span><span class="s4">0</span><span class="s1">] </span><span class="s3">for </span><span class="s1">v </span><span class="s3">in </span><span class="s1">self.__tokdict[i]])</span>
621  <a name="l601"><span class="ln">601  </span></a>
622  <a name="l602"><span class="ln">602  </span></a>    <span class="s3">def </span><span class="s1">__setitem__(self</span><span class="s3">, </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v</span><span class="s3">, </span><span class="s1">isinstance=isinstance):</span>
623  <a name="l603"><span class="ln">603  </span></a>        <span class="s3">if </span><span class="s1">isinstance(v</span><span class="s3">, </span><span class="s1">_ParseResultsWithOffset):</span>
624  <a name="l604"><span class="ln">604  </span></a>            <span class="s1">self.__tokdict[k] = self.__tokdict.get(k</span><span class="s3">, </span><span class="s1">list()) + [v]</span>
625  <a name="l605"><span class="ln">605  </span></a>            <span class="s1">sub = v[</span><span class="s4">0</span><span class="s1">]</span>
626  <a name="l606"><span class="ln">606  </span></a>        <span class="s3">elif </span><span class="s1">isinstance(k</span><span class="s3">, </span><span class="s1">(int</span><span class="s3">, </span><span class="s1">slice)):</span>
627  <a name="l607"><span class="ln">607  </span></a>            <span class="s1">self.__toklist[k] = v</span>
628  <a name="l608"><span class="ln">608  </span></a>            <span class="s1">sub = v</span>
629  <a name="l609"><span class="ln">609  </span></a>        <span class="s3">else</span><span class="s1">:</span>
630  <a name="l610"><span class="ln">610  </span></a>            <span class="s1">self.__tokdict[k] = self.__tokdict.get(k</span><span class="s3">, </span><span class="s1">list()) + [_ParseResultsWithOffset(v</span><span class="s3">, </span><span class="s4">0</span><span class="s1">)]</span>
631  <a name="l611"><span class="ln">611  </span></a>            <span class="s1">sub = v</span>
632  <a name="l612"><span class="ln">612  </span></a>        <span class="s3">if </span><span class="s1">isinstance(sub</span><span class="s3">, </span><span class="s1">ParseResults):</span>
633  <a name="l613"><span class="ln">613  </span></a>            <span class="s1">sub.__parent = wkref(self)</span>
634  <a name="l614"><span class="ln">614  </span></a>
635  <a name="l615"><span class="ln">615  </span></a>    <span class="s3">def </span><span class="s1">__delitem__(self</span><span class="s3">, </span><span class="s1">i):</span>
636  <a name="l616"><span class="ln">616  </span></a>        <span class="s3">if </span><span class="s1">isinstance(i</span><span class="s3">, </span><span class="s1">(int</span><span class="s3">, </span><span class="s1">slice)):</span>
637  <a name="l617"><span class="ln">617  </span></a>            <span class="s1">mylen = len(self.__toklist)</span>
638  <a name="l618"><span class="ln">618  </span></a>            <span class="s3">del </span><span class="s1">self.__toklist[i]</span>
639  <a name="l619"><span class="ln">619  </span></a>
640  <a name="l620"><span class="ln">620  </span></a>            <span class="s0"># convert int to slice</span>
641  <a name="l621"><span class="ln">621  </span></a>            <span class="s3">if </span><span class="s1">isinstance(i</span><span class="s3">, </span><span class="s1">int):</span>
642  <a name="l622"><span class="ln">622  </span></a>                <span class="s3">if </span><span class="s1">i &lt; </span><span class="s4">0</span><span class="s1">:</span>
643  <a name="l623"><span class="ln">623  </span></a>                    <span class="s1">i += mylen</span>
644  <a name="l624"><span class="ln">624  </span></a>                <span class="s1">i = slice(i</span><span class="s3">, </span><span class="s1">i + </span><span class="s4">1</span><span class="s1">)</span>
645  <a name="l625"><span class="ln">625  </span></a>            <span class="s0"># get removed indices</span>
646  <a name="l626"><span class="ln">626  </span></a>            <span class="s1">removed = list(range(*i.indices(mylen)))</span>
647  <a name="l627"><span class="ln">627  </span></a>            <span class="s1">removed.reverse()</span>
648  <a name="l628"><span class="ln">628  </span></a>            <span class="s0"># fixup indices in token dictionary</span>
649  <a name="l629"><span class="ln">629  </span></a>            <span class="s3">for </span><span class="s1">name</span><span class="s3">, </span><span class="s1">occurrences </span><span class="s3">in </span><span class="s1">self.__tokdict.items():</span>
650  <a name="l630"><span class="ln">630  </span></a>                <span class="s3">for </span><span class="s1">j </span><span class="s3">in </span><span class="s1">removed:</span>
651  <a name="l631"><span class="ln">631  </span></a>                    <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">(value</span><span class="s3">, </span><span class="s1">position) </span><span class="s3">in </span><span class="s1">enumerate(occurrences):</span>
652  <a name="l632"><span class="ln">632  </span></a>                        <span class="s1">occurrences[k] = _ParseResultsWithOffset(value</span><span class="s3">, </span><span class="s1">position - (position &gt; j))</span>
653  <a name="l633"><span class="ln">633  </span></a>        <span class="s3">else</span><span class="s1">:</span>
654  <a name="l634"><span class="ln">634  </span></a>            <span class="s3">del </span><span class="s1">self.__tokdict[i]</span>
655  <a name="l635"><span class="ln">635  </span></a>
656  <a name="l636"><span class="ln">636  </span></a>    <span class="s3">def </span><span class="s1">__contains__(self</span><span class="s3">, </span><span class="s1">k):</span>
657  <a name="l637"><span class="ln">637  </span></a>        <span class="s3">return </span><span class="s1">k </span><span class="s3">in </span><span class="s1">self.__tokdict</span>
658  <a name="l638"><span class="ln">638  </span></a>
659  <a name="l639"><span class="ln">639  </span></a>    <span class="s3">def </span><span class="s1">__len__(self):</span>
660  <a name="l640"><span class="ln">640  </span></a>        <span class="s3">return </span><span class="s1">len(self.__toklist)</span>
661  <a name="l641"><span class="ln">641  </span></a>
662  <a name="l642"><span class="ln">642  </span></a>    <span class="s3">def </span><span class="s1">__bool__(self):</span>
663  <a name="l643"><span class="ln">643  </span></a>        <span class="s3">return </span><span class="s1">(</span><span class="s3">not not </span><span class="s1">self.__toklist)</span>
664  <a name="l644"><span class="ln">644  </span></a>    <span class="s1">__nonzero__ = __bool__</span>
665  <a name="l645"><span class="ln">645  </span></a>
666  <a name="l646"><span class="ln">646  </span></a>    <span class="s3">def </span><span class="s1">__iter__(self):</span>
667  <a name="l647"><span class="ln">647  </span></a>        <span class="s3">return </span><span class="s1">iter(self.__toklist)</span>
668  <a name="l648"><span class="ln">648  </span></a>
669  <a name="l649"><span class="ln">649  </span></a>    <span class="s3">def </span><span class="s1">__reversed__(self):</span>
670  <a name="l650"><span class="ln">650  </span></a>        <span class="s3">return </span><span class="s1">iter(self.__toklist[::-</span><span class="s4">1</span><span class="s1">])</span>
671  <a name="l651"><span class="ln">651  </span></a>
672  <a name="l652"><span class="ln">652  </span></a>    <span class="s3">def </span><span class="s1">_iterkeys(self):</span>
673  <a name="l653"><span class="ln">653  </span></a>        <span class="s3">if </span><span class="s1">hasattr(self.__tokdict</span><span class="s3">, </span><span class="s2">&quot;iterkeys&quot;</span><span class="s1">):</span>
674  <a name="l654"><span class="ln">654  </span></a>            <span class="s3">return </span><span class="s1">self.__tokdict.iterkeys()</span>
675  <a name="l655"><span class="ln">655  </span></a>        <span class="s3">else</span><span class="s1">:</span>
676  <a name="l656"><span class="ln">656  </span></a>            <span class="s3">return </span><span class="s1">iter(self.__tokdict)</span>
677  <a name="l657"><span class="ln">657  </span></a>
678  <a name="l658"><span class="ln">658  </span></a>    <span class="s3">def </span><span class="s1">_itervalues(self):</span>
679  <a name="l659"><span class="ln">659  </span></a>        <span class="s3">return </span><span class="s1">(self[k] </span><span class="s3">for </span><span class="s1">k </span><span class="s3">in </span><span class="s1">self._iterkeys())</span>
680  <a name="l660"><span class="ln">660  </span></a>
681  <a name="l661"><span class="ln">661  </span></a>    <span class="s3">def </span><span class="s1">_iteritems(self):</span>
682  <a name="l662"><span class="ln">662  </span></a>        <span class="s3">return </span><span class="s1">((k</span><span class="s3">, </span><span class="s1">self[k]) </span><span class="s3">for </span><span class="s1">k </span><span class="s3">in </span><span class="s1">self._iterkeys())</span>
683  <a name="l663"><span class="ln">663  </span></a>
684  <a name="l664"><span class="ln">664  </span></a>    <span class="s3">if </span><span class="s1">PY_3:</span>
685  <a name="l665"><span class="ln">665  </span></a>        <span class="s1">keys = _iterkeys</span>
686  <a name="l666"><span class="ln">666  </span></a>        <span class="s2">&quot;&quot;&quot;Returns an iterator of all named result keys.&quot;&quot;&quot;</span>
687  <a name="l667"><span class="ln">667  </span></a>
688  <a name="l668"><span class="ln">668  </span></a>        <span class="s1">values = _itervalues</span>
689  <a name="l669"><span class="ln">669  </span></a>        <span class="s2">&quot;&quot;&quot;Returns an iterator of all named result values.&quot;&quot;&quot;</span>
690  <a name="l670"><span class="ln">670  </span></a>
691  <a name="l671"><span class="ln">671  </span></a>        <span class="s1">items = _iteritems</span>
692  <a name="l672"><span class="ln">672  </span></a>        <span class="s2">&quot;&quot;&quot;Returns an iterator of all named result key-value tuples.&quot;&quot;&quot;</span>
693  <a name="l673"><span class="ln">673  </span></a>
694  <a name="l674"><span class="ln">674  </span></a>    <span class="s3">else</span><span class="s1">:</span>
695  <a name="l675"><span class="ln">675  </span></a>        <span class="s1">iterkeys = _iterkeys</span>
696  <a name="l676"><span class="ln">676  </span></a>        <span class="s2">&quot;&quot;&quot;Returns an iterator of all named result keys (Python 2.x only).&quot;&quot;&quot;</span>
697  <a name="l677"><span class="ln">677  </span></a>
698  <a name="l678"><span class="ln">678  </span></a>        <span class="s1">itervalues = _itervalues</span>
699  <a name="l679"><span class="ln">679  </span></a>        <span class="s2">&quot;&quot;&quot;Returns an iterator of all named result values (Python 2.x only).&quot;&quot;&quot;</span>
700  <a name="l680"><span class="ln">680  </span></a>
701  <a name="l681"><span class="ln">681  </span></a>        <span class="s1">iteritems = _iteritems</span>
702  <a name="l682"><span class="ln">682  </span></a>        <span class="s2">&quot;&quot;&quot;Returns an iterator of all named result key-value tuples (Python 2.x only).&quot;&quot;&quot;</span>
703  <a name="l683"><span class="ln">683  </span></a>
704  <a name="l684"><span class="ln">684  </span></a>        <span class="s3">def </span><span class="s1">keys(self):</span>
705  <a name="l685"><span class="ln">685  </span></a>            <span class="s5">&quot;&quot;&quot;Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x).&quot;&quot;&quot;</span>
706  <a name="l686"><span class="ln">686  </span></a>            <span class="s3">return </span><span class="s1">list(self.iterkeys())</span>
707  <a name="l687"><span class="ln">687  </span></a>
708  <a name="l688"><span class="ln">688  </span></a>        <span class="s3">def </span><span class="s1">values(self):</span>
709  <a name="l689"><span class="ln">689  </span></a>            <span class="s5">&quot;&quot;&quot;Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x).&quot;&quot;&quot;</span>
710  <a name="l690"><span class="ln">690  </span></a>            <span class="s3">return </span><span class="s1">list(self.itervalues())</span>
711  <a name="l691"><span class="ln">691  </span></a>
712  <a name="l692"><span class="ln">692  </span></a>        <span class="s3">def </span><span class="s1">items(self):</span>
713  <a name="l693"><span class="ln">693  </span></a>            <span class="s5">&quot;&quot;&quot;Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x).&quot;&quot;&quot;</span>
714  <a name="l694"><span class="ln">694  </span></a>            <span class="s3">return </span><span class="s1">list(self.iteritems())</span>
715  <a name="l695"><span class="ln">695  </span></a>
716  <a name="l696"><span class="ln">696  </span></a>    <span class="s3">def </span><span class="s1">haskeys(self):</span>
717  <a name="l697"><span class="ln">697  </span></a>        <span class="s5">&quot;&quot;&quot;Since keys() returns an iterator, this method is helpful in bypassing 
718  <a name="l698"><span class="ln">698  </span></a>           code that looks for the existence of any defined results names.&quot;&quot;&quot;</span>
719  <a name="l699"><span class="ln">699  </span></a>        <span class="s3">return </span><span class="s1">bool(self.__tokdict)</span>
720  <a name="l700"><span class="ln">700  </span></a>
721  <a name="l701"><span class="ln">701  </span></a>    <span class="s3">def </span><span class="s1">pop(self</span><span class="s3">, </span><span class="s1">*args</span><span class="s3">, </span><span class="s1">**kwargs):</span>
722  <a name="l702"><span class="ln">702  </span></a>        <span class="s5">&quot;&quot;&quot; 
723  <a name="l703"><span class="ln">703  </span></a>        Removes and returns item at specified index (default= ``last``). 
724  <a name="l704"><span class="ln">704  </span></a>        Supports both ``list`` and ``dict`` semantics for ``pop()``. If 
725  <a name="l705"><span class="ln">705  </span></a>        passed no argument or an integer argument, it will use ``list`` 
726  <a name="l706"><span class="ln">706  </span></a>        semantics and pop tokens from the list of parsed tokens. If passed 
727  <a name="l707"><span class="ln">707  </span></a>        a non-integer argument (most likely a string), it will use ``dict`` 
728  <a name="l708"><span class="ln">708  </span></a>        semantics and pop the corresponding value from any defined results 
729  <a name="l709"><span class="ln">709  </span></a>        names. A second default return value argument is supported, just as in 
730  <a name="l710"><span class="ln">710  </span></a>        ``dict.pop()``. 
731  <a name="l711"><span class="ln">711  </span></a> 
732  <a name="l712"><span class="ln">712  </span></a>        Example:: 
733  <a name="l713"><span class="ln">713  </span></a> 
734  <a name="l714"><span class="ln">714  </span></a>            def remove_first(tokens): 
735  <a name="l715"><span class="ln">715  </span></a>                tokens.pop(0) 
736  <a name="l716"><span class="ln">716  </span></a>            print(OneOrMore(Word(nums)).parseString(&quot;0 123 321&quot;)) # -&gt; ['0', '123', '321'] 
737  <a name="l717"><span class="ln">717  </span></a>            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString(&quot;0 123 321&quot;)) # -&gt; ['123', '321'] 
738  <a name="l718"><span class="ln">718  </span></a> 
739  <a name="l719"><span class="ln">719  </span></a>            label = Word(alphas) 
740  <a name="l720"><span class="ln">720  </span></a>            patt = label(&quot;LABEL&quot;) + OneOrMore(Word(nums)) 
741  <a name="l721"><span class="ln">721  </span></a>            print(patt.parseString(&quot;AAB 123 321&quot;).dump()) 
742  <a name="l722"><span class="ln">722  </span></a> 
743  <a name="l723"><span class="ln">723  </span></a>            # Use pop() in a parse action to remove named result (note that corresponding value is not 
744  <a name="l724"><span class="ln">724  </span></a>            # removed from list form of results) 
745  <a name="l725"><span class="ln">725  </span></a>            def remove_LABEL(tokens): 
746  <a name="l726"><span class="ln">726  </span></a>                tokens.pop(&quot;LABEL&quot;) 
747  <a name="l727"><span class="ln">727  </span></a>                return tokens 
748  <a name="l728"><span class="ln">728  </span></a>            patt.addParseAction(remove_LABEL) 
749  <a name="l729"><span class="ln">729  </span></a>            print(patt.parseString(&quot;AAB 123 321&quot;).dump()) 
750  <a name="l730"><span class="ln">730  </span></a> 
751  <a name="l731"><span class="ln">731  </span></a>        prints:: 
752  <a name="l732"><span class="ln">732  </span></a> 
753  <a name="l733"><span class="ln">733  </span></a>            ['AAB', '123', '321'] 
754  <a name="l734"><span class="ln">734  </span></a>            - LABEL: AAB 
755  <a name="l735"><span class="ln">735  </span></a> 
756  <a name="l736"><span class="ln">736  </span></a>            ['AAB', '123', '321'] 
757  <a name="l737"><span class="ln">737  </span></a>        &quot;&quot;&quot;</span>
758  <a name="l738"><span class="ln">738  </span></a>        <span class="s3">if not </span><span class="s1">args:</span>
759  <a name="l739"><span class="ln">739  </span></a>            <span class="s1">args = [-</span><span class="s4">1</span><span class="s1">]</span>
760  <a name="l740"><span class="ln">740  </span></a>        <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">kwargs.items():</span>
761  <a name="l741"><span class="ln">741  </span></a>            <span class="s3">if </span><span class="s1">k == </span><span class="s2">'default'</span><span class="s1">:</span>
762  <a name="l742"><span class="ln">742  </span></a>                <span class="s1">args = (args[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">v)</span>
763  <a name="l743"><span class="ln">743  </span></a>            <span class="s3">else</span><span class="s1">:</span>
764  <a name="l744"><span class="ln">744  </span></a>                <span class="s3">raise </span><span class="s1">TypeError(</span><span class="s2">&quot;pop() got an unexpected keyword argument '%s'&quot; </span><span class="s1">% k)</span>
765  <a name="l745"><span class="ln">745  </span></a>        <span class="s3">if </span><span class="s1">(isinstance(args[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">int)</span>
766  <a name="l746"><span class="ln">746  </span></a>                <span class="s3">or </span><span class="s1">len(args) == </span><span class="s4">1</span>
767  <a name="l747"><span class="ln">747  </span></a>                <span class="s3">or </span><span class="s1">args[</span><span class="s4">0</span><span class="s1">] </span><span class="s3">in </span><span class="s1">self):</span>
768  <a name="l748"><span class="ln">748  </span></a>            <span class="s1">index = args[</span><span class="s4">0</span><span class="s1">]</span>
769  <a name="l749"><span class="ln">749  </span></a>            <span class="s1">ret = self[index]</span>
770  <a name="l750"><span class="ln">750  </span></a>            <span class="s3">del </span><span class="s1">self[index]</span>
771  <a name="l751"><span class="ln">751  </span></a>            <span class="s3">return </span><span class="s1">ret</span>
772  <a name="l752"><span class="ln">752  </span></a>        <span class="s3">else</span><span class="s1">:</span>
773  <a name="l753"><span class="ln">753  </span></a>            <span class="s1">defaultvalue = args[</span><span class="s4">1</span><span class="s1">]</span>
774  <a name="l754"><span class="ln">754  </span></a>            <span class="s3">return </span><span class="s1">defaultvalue</span>
775  <a name="l755"><span class="ln">755  </span></a>
776  <a name="l756"><span class="ln">756  </span></a>    <span class="s3">def </span><span class="s1">get(self</span><span class="s3">, </span><span class="s1">key</span><span class="s3">, </span><span class="s1">defaultValue=</span><span class="s3">None</span><span class="s1">):</span>
777  <a name="l757"><span class="ln">757  </span></a>        <span class="s5">&quot;&quot;&quot; 
778  <a name="l758"><span class="ln">758  </span></a>        Returns named result matching the given key, or if there is no 
779  <a name="l759"><span class="ln">759  </span></a>        such name, then returns the given ``defaultValue`` or ``None`` if no 
780  <a name="l760"><span class="ln">760  </span></a>        ``defaultValue`` is specified. 
781  <a name="l761"><span class="ln">761  </span></a> 
782  <a name="l762"><span class="ln">762  </span></a>        Similar to ``dict.get()``. 
783  <a name="l763"><span class="ln">763  </span></a> 
784  <a name="l764"><span class="ln">764  </span></a>        Example:: 
785  <a name="l765"><span class="ln">765  </span></a> 
786  <a name="l766"><span class="ln">766  </span></a>            integer = Word(nums) 
787  <a name="l767"><span class="ln">767  </span></a>            date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
788  <a name="l768"><span class="ln">768  </span></a> 
789  <a name="l769"><span class="ln">769  </span></a>            result = date_str.parseString(&quot;1999/12/31&quot;) 
790  <a name="l770"><span class="ln">770  </span></a>            print(result.get(&quot;year&quot;)) # -&gt; '1999' 
791  <a name="l771"><span class="ln">771  </span></a>            print(result.get(&quot;hour&quot;, &quot;not specified&quot;)) # -&gt; 'not specified' 
792  <a name="l772"><span class="ln">772  </span></a>            print(result.get(&quot;hour&quot;)) # -&gt; None 
793  <a name="l773"><span class="ln">773  </span></a>        &quot;&quot;&quot;</span>
794  <a name="l774"><span class="ln">774  </span></a>        <span class="s3">if </span><span class="s1">key </span><span class="s3">in </span><span class="s1">self:</span>
795  <a name="l775"><span class="ln">775  </span></a>            <span class="s3">return </span><span class="s1">self[key]</span>
796  <a name="l776"><span class="ln">776  </span></a>        <span class="s3">else</span><span class="s1">:</span>
797  <a name="l777"><span class="ln">777  </span></a>            <span class="s3">return </span><span class="s1">defaultValue</span>
798  <a name="l778"><span class="ln">778  </span></a>
799  <a name="l779"><span class="ln">779  </span></a>    <span class="s3">def </span><span class="s1">insert(self</span><span class="s3">, </span><span class="s1">index</span><span class="s3">, </span><span class="s1">insStr):</span>
800  <a name="l780"><span class="ln">780  </span></a>        <span class="s5">&quot;&quot;&quot; 
801  <a name="l781"><span class="ln">781  </span></a>        Inserts new element at location index in the list of parsed tokens. 
802  <a name="l782"><span class="ln">782  </span></a> 
803  <a name="l783"><span class="ln">783  </span></a>        Similar to ``list.insert()``. 
804  <a name="l784"><span class="ln">784  </span></a> 
805  <a name="l785"><span class="ln">785  </span></a>        Example:: 
806  <a name="l786"><span class="ln">786  </span></a> 
807  <a name="l787"><span class="ln">787  </span></a>            print(OneOrMore(Word(nums)).parseString(&quot;0 123 321&quot;)) # -&gt; ['0', '123', '321'] 
808  <a name="l788"><span class="ln">788  </span></a> 
809  <a name="l789"><span class="ln">789  </span></a>            # use a parse action to insert the parse location in the front of the parsed results 
810  <a name="l790"><span class="ln">790  </span></a>            def insert_locn(locn, tokens): 
811  <a name="l791"><span class="ln">791  </span></a>                tokens.insert(0, locn) 
812  <a name="l792"><span class="ln">792  </span></a>            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString(&quot;0 123 321&quot;)) # -&gt; [0, '0', '123', '321'] 
813  <a name="l793"><span class="ln">793  </span></a>        &quot;&quot;&quot;</span>
814  <a name="l794"><span class="ln">794  </span></a>        <span class="s1">self.__toklist.insert(index</span><span class="s3">, </span><span class="s1">insStr)</span>
815  <a name="l795"><span class="ln">795  </span></a>        <span class="s0"># fixup indices in token dictionary</span>
816  <a name="l796"><span class="ln">796  </span></a>        <span class="s3">for </span><span class="s1">name</span><span class="s3">, </span><span class="s1">occurrences </span><span class="s3">in </span><span class="s1">self.__tokdict.items():</span>
817  <a name="l797"><span class="ln">797  </span></a>            <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">(value</span><span class="s3">, </span><span class="s1">position) </span><span class="s3">in </span><span class="s1">enumerate(occurrences):</span>
818  <a name="l798"><span class="ln">798  </span></a>                <span class="s1">occurrences[k] = _ParseResultsWithOffset(value</span><span class="s3">, </span><span class="s1">position + (position &gt; index))</span>
819  <a name="l799"><span class="ln">799  </span></a>
820  <a name="l800"><span class="ln">800  </span></a>    <span class="s3">def </span><span class="s1">append(self</span><span class="s3">, </span><span class="s1">item):</span>
821  <a name="l801"><span class="ln">801  </span></a>        <span class="s5">&quot;&quot;&quot; 
822  <a name="l802"><span class="ln">802  </span></a>        Add single element to end of ParseResults list of elements. 
823  <a name="l803"><span class="ln">803  </span></a> 
824  <a name="l804"><span class="ln">804  </span></a>        Example:: 
825  <a name="l805"><span class="ln">805  </span></a> 
826  <a name="l806"><span class="ln">806  </span></a>            print(OneOrMore(Word(nums)).parseString(&quot;0 123 321&quot;)) # -&gt; ['0', '123', '321'] 
827  <a name="l807"><span class="ln">807  </span></a> 
828  <a name="l808"><span class="ln">808  </span></a>            # use a parse action to compute the sum of the parsed integers, and add it to the end 
829  <a name="l809"><span class="ln">809  </span></a>            def append_sum(tokens): 
830  <a name="l810"><span class="ln">810  </span></a>                tokens.append(sum(map(int, tokens))) 
831  <a name="l811"><span class="ln">811  </span></a>            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString(&quot;0 123 321&quot;)) # -&gt; ['0', '123', '321', 444] 
832  <a name="l812"><span class="ln">812  </span></a>        &quot;&quot;&quot;</span>
833  <a name="l813"><span class="ln">813  </span></a>        <span class="s1">self.__toklist.append(item)</span>
834  <a name="l814"><span class="ln">814  </span></a>
835  <a name="l815"><span class="ln">815  </span></a>    <span class="s3">def </span><span class="s1">extend(self</span><span class="s3">, </span><span class="s1">itemseq):</span>
836  <a name="l816"><span class="ln">816  </span></a>        <span class="s5">&quot;&quot;&quot; 
837  <a name="l817"><span class="ln">817  </span></a>        Add sequence of elements to end of ParseResults list of elements. 
838  <a name="l818"><span class="ln">818  </span></a> 
839  <a name="l819"><span class="ln">819  </span></a>        Example:: 
840  <a name="l820"><span class="ln">820  </span></a> 
841  <a name="l821"><span class="ln">821  </span></a>            patt = OneOrMore(Word(alphas)) 
842  <a name="l822"><span class="ln">822  </span></a> 
843  <a name="l823"><span class="ln">823  </span></a>            # use a parse action to append the reverse of the matched strings, to make a palindrome 
844  <a name="l824"><span class="ln">824  </span></a>            def make_palindrome(tokens): 
845  <a name="l825"><span class="ln">825  </span></a>                tokens.extend(reversed([t[::-1] for t in tokens])) 
846  <a name="l826"><span class="ln">826  </span></a>                return ''.join(tokens) 
847  <a name="l827"><span class="ln">827  </span></a>            print(patt.addParseAction(make_palindrome).parseString(&quot;lskdj sdlkjf lksd&quot;)) # -&gt; 'lskdjsdlkjflksddsklfjkldsjdksl' 
848  <a name="l828"><span class="ln">828  </span></a>        &quot;&quot;&quot;</span>
849  <a name="l829"><span class="ln">829  </span></a>        <span class="s3">if </span><span class="s1">isinstance(itemseq</span><span class="s3">, </span><span class="s1">ParseResults):</span>
850  <a name="l830"><span class="ln">830  </span></a>            <span class="s1">self.__iadd__(itemseq)</span>
851  <a name="l831"><span class="ln">831  </span></a>        <span class="s3">else</span><span class="s1">:</span>
852  <a name="l832"><span class="ln">832  </span></a>            <span class="s1">self.__toklist.extend(itemseq)</span>
853  <a name="l833"><span class="ln">833  </span></a>
854  <a name="l834"><span class="ln">834  </span></a>    <span class="s3">def </span><span class="s1">clear(self):</span>
855  <a name="l835"><span class="ln">835  </span></a>        <span class="s5">&quot;&quot;&quot; 
856  <a name="l836"><span class="ln">836  </span></a>        Clear all elements and results names. 
857  <a name="l837"><span class="ln">837  </span></a>        &quot;&quot;&quot;</span>
858  <a name="l838"><span class="ln">838  </span></a>        <span class="s3">del </span><span class="s1">self.__toklist[:]</span>
859  <a name="l839"><span class="ln">839  </span></a>        <span class="s1">self.__tokdict.clear()</span>
860  <a name="l840"><span class="ln">840  </span></a>
861  <a name="l841"><span class="ln">841  </span></a>    <span class="s3">def </span><span class="s1">__getattr__(self</span><span class="s3">, </span><span class="s1">name):</span>
862  <a name="l842"><span class="ln">842  </span></a>        <span class="s3">try</span><span class="s1">:</span>
863  <a name="l843"><span class="ln">843  </span></a>            <span class="s3">return </span><span class="s1">self[name]</span>
864  <a name="l844"><span class="ln">844  </span></a>        <span class="s3">except </span><span class="s1">KeyError:</span>
865  <a name="l845"><span class="ln">845  </span></a>            <span class="s3">return </span><span class="s2">&quot;&quot;</span>
866  <a name="l846"><span class="ln">846  </span></a>
867  <a name="l847"><span class="ln">847  </span></a>    <span class="s3">def </span><span class="s1">__add__(self</span><span class="s3">, </span><span class="s1">other):</span>
868  <a name="l848"><span class="ln">848  </span></a>        <span class="s1">ret = self.copy()</span>
869  <a name="l849"><span class="ln">849  </span></a>        <span class="s1">ret += other</span>
870  <a name="l850"><span class="ln">850  </span></a>        <span class="s3">return </span><span class="s1">ret</span>
871  <a name="l851"><span class="ln">851  </span></a>
872  <a name="l852"><span class="ln">852  </span></a>    <span class="s3">def </span><span class="s1">__iadd__(self</span><span class="s3">, </span><span class="s1">other):</span>
873  <a name="l853"><span class="ln">853  </span></a>        <span class="s3">if </span><span class="s1">other.__tokdict:</span>
874  <a name="l854"><span class="ln">854  </span></a>            <span class="s1">offset = len(self.__toklist)</span>
875  <a name="l855"><span class="ln">855  </span></a>            <span class="s1">addoffset = </span><span class="s3">lambda </span><span class="s1">a: offset </span><span class="s3">if </span><span class="s1">a &lt; </span><span class="s4">0 </span><span class="s3">else </span><span class="s1">a + offset</span>
876  <a name="l856"><span class="ln">856  </span></a>            <span class="s1">otheritems = other.__tokdict.items()</span>
877  <a name="l857"><span class="ln">857  </span></a>            <span class="s1">otherdictitems = [(k</span><span class="s3">, </span><span class="s1">_ParseResultsWithOffset(v[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">addoffset(v[</span><span class="s4">1</span><span class="s1">])))</span>
878  <a name="l858"><span class="ln">858  </span></a>                              <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">vlist </span><span class="s3">in </span><span class="s1">otheritems </span><span class="s3">for </span><span class="s1">v </span><span class="s3">in </span><span class="s1">vlist]</span>
879  <a name="l859"><span class="ln">859  </span></a>            <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">otherdictitems:</span>
880  <a name="l860"><span class="ln">860  </span></a>                <span class="s1">self[k] = v</span>
881  <a name="l861"><span class="ln">861  </span></a>                <span class="s3">if </span><span class="s1">isinstance(v[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">ParseResults):</span>
882  <a name="l862"><span class="ln">862  </span></a>                    <span class="s1">v[</span><span class="s4">0</span><span class="s1">].__parent = wkref(self)</span>
883  <a name="l863"><span class="ln">863  </span></a>
884  <a name="l864"><span class="ln">864  </span></a>        <span class="s1">self.__toklist += other.__toklist</span>
885  <a name="l865"><span class="ln">865  </span></a>        <span class="s1">self.__accumNames.update(other.__accumNames)</span>
886  <a name="l866"><span class="ln">866  </span></a>        <span class="s3">return </span><span class="s1">self</span>
887  <a name="l867"><span class="ln">867  </span></a>
888  <a name="l868"><span class="ln">868  </span></a>    <span class="s3">def </span><span class="s1">__radd__(self</span><span class="s3">, </span><span class="s1">other):</span>
889  <a name="l869"><span class="ln">869  </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">int) </span><span class="s3">and </span><span class="s1">other == </span><span class="s4">0</span><span class="s1">:</span>
890  <a name="l870"><span class="ln">870  </span></a>            <span class="s0"># useful for merging many ParseResults using sum() builtin</span>
891  <a name="l871"><span class="ln">871  </span></a>            <span class="s3">return </span><span class="s1">self.copy()</span>
892  <a name="l872"><span class="ln">872  </span></a>        <span class="s3">else</span><span class="s1">:</span>
893  <a name="l873"><span class="ln">873  </span></a>            <span class="s0"># this may raise a TypeError - so be it</span>
894  <a name="l874"><span class="ln">874  </span></a>            <span class="s3">return </span><span class="s1">other + self</span>
895  <a name="l875"><span class="ln">875  </span></a>
896  <a name="l876"><span class="ln">876  </span></a>    <span class="s3">def </span><span class="s1">__repr__(self):</span>
897  <a name="l877"><span class="ln">877  </span></a>        <span class="s3">return </span><span class="s2">&quot;(%s, %s)&quot; </span><span class="s1">% (repr(self.__toklist)</span><span class="s3">, </span><span class="s1">repr(self.__tokdict))</span>
898  <a name="l878"><span class="ln">878  </span></a>
899  <a name="l879"><span class="ln">879  </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
900  <a name="l880"><span class="ln">880  </span></a>        <span class="s3">return </span><span class="s2">'[' </span><span class="s1">+ </span><span class="s2">', '</span><span class="s1">.join(_ustr(i) </span><span class="s3">if </span><span class="s1">isinstance(i</span><span class="s3">, </span><span class="s1">ParseResults) </span><span class="s3">else </span><span class="s1">repr(i) </span><span class="s3">for </span><span class="s1">i </span><span class="s3">in </span><span class="s1">self.__toklist) + </span><span class="s2">']'</span>
901  <a name="l881"><span class="ln">881  </span></a>
902  <a name="l882"><span class="ln">882  </span></a>    <span class="s3">def </span><span class="s1">_asStringList(self</span><span class="s3">, </span><span class="s1">sep=</span><span class="s2">''</span><span class="s1">):</span>
903  <a name="l883"><span class="ln">883  </span></a>        <span class="s1">out = []</span>
904  <a name="l884"><span class="ln">884  </span></a>        <span class="s3">for </span><span class="s1">item </span><span class="s3">in </span><span class="s1">self.__toklist:</span>
905  <a name="l885"><span class="ln">885  </span></a>            <span class="s3">if </span><span class="s1">out </span><span class="s3">and </span><span class="s1">sep:</span>
906  <a name="l886"><span class="ln">886  </span></a>                <span class="s1">out.append(sep)</span>
907  <a name="l887"><span class="ln">887  </span></a>            <span class="s3">if </span><span class="s1">isinstance(item</span><span class="s3">, </span><span class="s1">ParseResults):</span>
908  <a name="l888"><span class="ln">888  </span></a>                <span class="s1">out += item._asStringList()</span>
909  <a name="l889"><span class="ln">889  </span></a>            <span class="s3">else</span><span class="s1">:</span>
910  <a name="l890"><span class="ln">890  </span></a>                <span class="s1">out.append(_ustr(item))</span>
911  <a name="l891"><span class="ln">891  </span></a>        <span class="s3">return </span><span class="s1">out</span>
912  <a name="l892"><span class="ln">892  </span></a>
913  <a name="l893"><span class="ln">893  </span></a>    <span class="s3">def </span><span class="s1">asList(self):</span>
914  <a name="l894"><span class="ln">894  </span></a>        <span class="s5">&quot;&quot;&quot; 
915  <a name="l895"><span class="ln">895  </span></a>        Returns the parse results as a nested list of matching tokens, all converted to strings. 
916  <a name="l896"><span class="ln">896  </span></a> 
917  <a name="l897"><span class="ln">897  </span></a>        Example:: 
918  <a name="l898"><span class="ln">898  </span></a> 
919  <a name="l899"><span class="ln">899  </span></a>            patt = OneOrMore(Word(alphas)) 
920  <a name="l900"><span class="ln">900  </span></a>            result = patt.parseString(&quot;sldkj lsdkj sldkj&quot;) 
921  <a name="l901"><span class="ln">901  </span></a>            # even though the result prints in string-like form, it is actually a pyparsing ParseResults 
922  <a name="l902"><span class="ln">902  </span></a>            print(type(result), result) # -&gt; &lt;class 'pyparsing.ParseResults'&gt; ['sldkj', 'lsdkj', 'sldkj'] 
923  <a name="l903"><span class="ln">903  </span></a> 
924  <a name="l904"><span class="ln">904  </span></a>            # Use asList() to create an actual list 
925  <a name="l905"><span class="ln">905  </span></a>            result_list = result.asList() 
926  <a name="l906"><span class="ln">906  </span></a>            print(type(result_list), result_list) # -&gt; &lt;class 'list'&gt; ['sldkj', 'lsdkj', 'sldkj'] 
927  <a name="l907"><span class="ln">907  </span></a>        &quot;&quot;&quot;</span>
928  <a name="l908"><span class="ln">908  </span></a>        <span class="s3">return </span><span class="s1">[res.asList() </span><span class="s3">if </span><span class="s1">isinstance(res</span><span class="s3">, </span><span class="s1">ParseResults) </span><span class="s3">else </span><span class="s1">res </span><span class="s3">for </span><span class="s1">res </span><span class="s3">in </span><span class="s1">self.__toklist]</span>
929  <a name="l909"><span class="ln">909  </span></a>
930  <a name="l910"><span class="ln">910  </span></a>    <span class="s3">def </span><span class="s1">asDict(self):</span>
931  <a name="l911"><span class="ln">911  </span></a>        <span class="s5">&quot;&quot;&quot; 
932  <a name="l912"><span class="ln">912  </span></a>        Returns the named parse results as a nested dictionary. 
933  <a name="l913"><span class="ln">913  </span></a> 
934  <a name="l914"><span class="ln">914  </span></a>        Example:: 
935  <a name="l915"><span class="ln">915  </span></a> 
936  <a name="l916"><span class="ln">916  </span></a>            integer = Word(nums) 
937  <a name="l917"><span class="ln">917  </span></a>            date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
938  <a name="l918"><span class="ln">918  </span></a> 
939  <a name="l919"><span class="ln">919  </span></a>            result = date_str.parseString('12/31/1999') 
940  <a name="l920"><span class="ln">920  </span></a>            print(type(result), repr(result)) # -&gt; &lt;class 'pyparsing.ParseResults'&gt; (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]}) 
941  <a name="l921"><span class="ln">921  </span></a> 
942  <a name="l922"><span class="ln">922  </span></a>            result_dict = result.asDict() 
943  <a name="l923"><span class="ln">923  </span></a>            print(type(result_dict), repr(result_dict)) # -&gt; &lt;class 'dict'&gt; {'day': '1999', 'year': '12', 'month': '31'} 
944  <a name="l924"><span class="ln">924  </span></a> 
945  <a name="l925"><span class="ln">925  </span></a>            # even though a ParseResults supports dict-like access, sometime you just need to have a dict 
946  <a name="l926"><span class="ln">926  </span></a>            import json 
947  <a name="l927"><span class="ln">927  </span></a>            print(json.dumps(result)) # -&gt; Exception: TypeError: ... is not JSON serializable 
948  <a name="l928"><span class="ln">928  </span></a>            print(json.dumps(result.asDict())) # -&gt; {&quot;month&quot;: &quot;31&quot;, &quot;day&quot;: &quot;1999&quot;, &quot;year&quot;: &quot;12&quot;} 
949  <a name="l929"><span class="ln">929  </span></a>        &quot;&quot;&quot;</span>
950  <a name="l930"><span class="ln">930  </span></a>        <span class="s3">if </span><span class="s1">PY_3:</span>
951  <a name="l931"><span class="ln">931  </span></a>            <span class="s1">item_fn = self.items</span>
952  <a name="l932"><span class="ln">932  </span></a>        <span class="s3">else</span><span class="s1">:</span>
953  <a name="l933"><span class="ln">933  </span></a>            <span class="s1">item_fn = self.iteritems</span>
954  <a name="l934"><span class="ln">934  </span></a>
955  <a name="l935"><span class="ln">935  </span></a>        <span class="s3">def </span><span class="s1">toItem(obj):</span>
956  <a name="l936"><span class="ln">936  </span></a>            <span class="s3">if </span><span class="s1">isinstance(obj</span><span class="s3">, </span><span class="s1">ParseResults):</span>
957  <a name="l937"><span class="ln">937  </span></a>                <span class="s3">if </span><span class="s1">obj.haskeys():</span>
958  <a name="l938"><span class="ln">938  </span></a>                    <span class="s3">return </span><span class="s1">obj.asDict()</span>
959  <a name="l939"><span class="ln">939  </span></a>                <span class="s3">else</span><span class="s1">:</span>
960  <a name="l940"><span class="ln">940  </span></a>                    <span class="s3">return </span><span class="s1">[toItem(v) </span><span class="s3">for </span><span class="s1">v </span><span class="s3">in </span><span class="s1">obj]</span>
961  <a name="l941"><span class="ln">941  </span></a>            <span class="s3">else</span><span class="s1">:</span>
962  <a name="l942"><span class="ln">942  </span></a>                <span class="s3">return </span><span class="s1">obj</span>
963  <a name="l943"><span class="ln">943  </span></a>
964  <a name="l944"><span class="ln">944  </span></a>        <span class="s3">return </span><span class="s1">dict((k</span><span class="s3">, </span><span class="s1">toItem(v)) </span><span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">item_fn())</span>
965  <a name="l945"><span class="ln">945  </span></a>
966  <a name="l946"><span class="ln">946  </span></a>    <span class="s3">def </span><span class="s1">copy(self):</span>
967  <a name="l947"><span class="ln">947  </span></a>        <span class="s5">&quot;&quot;&quot; 
968  <a name="l948"><span class="ln">948  </span></a>        Returns a new copy of a :class:`ParseResults` object. 
969  <a name="l949"><span class="ln">949  </span></a>        &quot;&quot;&quot;</span>
970  <a name="l950"><span class="ln">950  </span></a>        <span class="s1">ret = ParseResults(self.__toklist)</span>
971  <a name="l951"><span class="ln">951  </span></a>        <span class="s1">ret.__tokdict = dict(self.__tokdict.items())</span>
972  <a name="l952"><span class="ln">952  </span></a>        <span class="s1">ret.__parent = self.__parent</span>
973  <a name="l953"><span class="ln">953  </span></a>        <span class="s1">ret.__accumNames.update(self.__accumNames)</span>
974  <a name="l954"><span class="ln">954  </span></a>        <span class="s1">ret.__name = self.__name</span>
975  <a name="l955"><span class="ln">955  </span></a>        <span class="s3">return </span><span class="s1">ret</span>
976  <a name="l956"><span class="ln">956  </span></a>
977  <a name="l957"><span class="ln">957  </span></a>    <span class="s3">def </span><span class="s1">asXML(self</span><span class="s3">, </span><span class="s1">doctag=</span><span class="s3">None, </span><span class="s1">namedItemsOnly=</span><span class="s3">False, </span><span class="s1">indent=</span><span class="s2">&quot;&quot;</span><span class="s3">, </span><span class="s1">formatted=</span><span class="s3">True</span><span class="s1">):</span>
978  <a name="l958"><span class="ln">958  </span></a>        <span class="s5">&quot;&quot;&quot; 
979  <a name="l959"><span class="ln">959  </span></a>        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names. 
980  <a name="l960"><span class="ln">960  </span></a>        &quot;&quot;&quot;</span>
981  <a name="l961"><span class="ln">961  </span></a>        <span class="s1">nl = </span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span>
982  <a name="l962"><span class="ln">962  </span></a>        <span class="s1">out = []</span>
983  <a name="l963"><span class="ln">963  </span></a>        <span class="s1">namedItems = dict((v[</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">k) </span><span class="s3">for </span><span class="s1">(k</span><span class="s3">, </span><span class="s1">vlist) </span><span class="s3">in </span><span class="s1">self.__tokdict.items()</span>
984  <a name="l964"><span class="ln">964  </span></a>                          <span class="s3">for </span><span class="s1">v </span><span class="s3">in </span><span class="s1">vlist)</span>
985  <a name="l965"><span class="ln">965  </span></a>        <span class="s1">nextLevelIndent = indent + </span><span class="s2">&quot;  &quot;</span>
986  <a name="l966"><span class="ln">966  </span></a>
987  <a name="l967"><span class="ln">967  </span></a>        <span class="s0"># collapse out indents if formatting is not desired</span>
988  <a name="l968"><span class="ln">968  </span></a>        <span class="s3">if not </span><span class="s1">formatted:</span>
989  <a name="l969"><span class="ln">969  </span></a>            <span class="s1">indent = </span><span class="s2">&quot;&quot;</span>
990  <a name="l970"><span class="ln">970  </span></a>            <span class="s1">nextLevelIndent = </span><span class="s2">&quot;&quot;</span>
991  <a name="l971"><span class="ln">971  </span></a>            <span class="s1">nl = </span><span class="s2">&quot;&quot;</span>
992  <a name="l972"><span class="ln">972  </span></a>
993  <a name="l973"><span class="ln">973  </span></a>        <span class="s1">selfTag = </span><span class="s3">None</span>
994  <a name="l974"><span class="ln">974  </span></a>        <span class="s3">if </span><span class="s1">doctag </span><span class="s3">is not None</span><span class="s1">:</span>
995  <a name="l975"><span class="ln">975  </span></a>            <span class="s1">selfTag = doctag</span>
996  <a name="l976"><span class="ln">976  </span></a>        <span class="s3">else</span><span class="s1">:</span>
997  <a name="l977"><span class="ln">977  </span></a>            <span class="s3">if </span><span class="s1">self.__name:</span>
998  <a name="l978"><span class="ln">978  </span></a>                <span class="s1">selfTag = self.__name</span>
999  <a name="l979"><span class="ln">979  </span></a>
1000 <a name="l980"><span class="ln">980  </span></a>        <span class="s3">if not </span><span class="s1">selfTag:</span>
1001 <a name="l981"><span class="ln">981  </span></a>            <span class="s3">if </span><span class="s1">namedItemsOnly:</span>
1002 <a name="l982"><span class="ln">982  </span></a>                <span class="s3">return </span><span class="s2">&quot;&quot;</span>
1003 <a name="l983"><span class="ln">983  </span></a>            <span class="s3">else</span><span class="s1">:</span>
1004 <a name="l984"><span class="ln">984  </span></a>                <span class="s1">selfTag = </span><span class="s2">&quot;ITEM&quot;</span>
1005 <a name="l985"><span class="ln">985  </span></a>
1006 <a name="l986"><span class="ln">986  </span></a>        <span class="s1">out += [nl</span><span class="s3">, </span><span class="s1">indent</span><span class="s3">, </span><span class="s2">&quot;&lt;&quot;</span><span class="s3">, </span><span class="s1">selfTag</span><span class="s3">, </span><span class="s2">&quot;&gt;&quot;</span><span class="s1">]</span>
1007 <a name="l987"><span class="ln">987  </span></a>
1008 <a name="l988"><span class="ln">988  </span></a>        <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">res </span><span class="s3">in </span><span class="s1">enumerate(self.__toklist):</span>
1009 <a name="l989"><span class="ln">989  </span></a>            <span class="s3">if </span><span class="s1">isinstance(res</span><span class="s3">, </span><span class="s1">ParseResults):</span>
1010 <a name="l990"><span class="ln">990  </span></a>                <span class="s3">if </span><span class="s1">i </span><span class="s3">in </span><span class="s1">namedItems:</span>
1011 <a name="l991"><span class="ln">991  </span></a>                    <span class="s1">out += [res.asXML(namedItems[i]</span><span class="s3">,</span>
1012 <a name="l992"><span class="ln">992  </span></a>                                      <span class="s1">namedItemsOnly </span><span class="s3">and </span><span class="s1">doctag </span><span class="s3">is None,</span>
1013 <a name="l993"><span class="ln">993  </span></a>                                      <span class="s1">nextLevelIndent</span><span class="s3">,</span>
1014 <a name="l994"><span class="ln">994  </span></a>                                      <span class="s1">formatted)]</span>
1015 <a name="l995"><span class="ln">995  </span></a>                <span class="s3">else</span><span class="s1">:</span>
1016 <a name="l996"><span class="ln">996  </span></a>                    <span class="s1">out += [res.asXML(</span><span class="s3">None,</span>
1017 <a name="l997"><span class="ln">997  </span></a>                                      <span class="s1">namedItemsOnly </span><span class="s3">and </span><span class="s1">doctag </span><span class="s3">is None,</span>
1018 <a name="l998"><span class="ln">998  </span></a>                                      <span class="s1">nextLevelIndent</span><span class="s3">,</span>
1019 <a name="l999"><span class="ln">999  </span></a>                                      <span class="s1">formatted)]</span>
1020 <a name="l1000"><span class="ln">1000 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1021 <a name="l1001"><span class="ln">1001 </span></a>                <span class="s0"># individual token, see if there is a name for it</span>
1022 <a name="l1002"><span class="ln">1002 </span></a>                <span class="s1">resTag = </span><span class="s3">None</span>
1023 <a name="l1003"><span class="ln">1003 </span></a>                <span class="s3">if </span><span class="s1">i </span><span class="s3">in </span><span class="s1">namedItems:</span>
1024 <a name="l1004"><span class="ln">1004 </span></a>                    <span class="s1">resTag = namedItems[i]</span>
1025 <a name="l1005"><span class="ln">1005 </span></a>                <span class="s3">if not </span><span class="s1">resTag:</span>
1026 <a name="l1006"><span class="ln">1006 </span></a>                    <span class="s3">if </span><span class="s1">namedItemsOnly:</span>
1027 <a name="l1007"><span class="ln">1007 </span></a>                        <span class="s3">continue</span>
1028 <a name="l1008"><span class="ln">1008 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
1029 <a name="l1009"><span class="ln">1009 </span></a>                        <span class="s1">resTag = </span><span class="s2">&quot;ITEM&quot;</span>
1030 <a name="l1010"><span class="ln">1010 </span></a>                <span class="s1">xmlBodyText = _xml_escape(_ustr(res))</span>
1031 <a name="l1011"><span class="ln">1011 </span></a>                <span class="s1">out += [nl</span><span class="s3">, </span><span class="s1">nextLevelIndent</span><span class="s3">, </span><span class="s2">&quot;&lt;&quot;</span><span class="s3">, </span><span class="s1">resTag</span><span class="s3">, </span><span class="s2">&quot;&gt;&quot;</span><span class="s3">,</span>
1032 <a name="l1012"><span class="ln">1012 </span></a>                        <span class="s1">xmlBodyText</span><span class="s3">,</span>
1033 <a name="l1013"><span class="ln">1013 </span></a>                                                <span class="s2">&quot;&lt;/&quot;</span><span class="s3">, </span><span class="s1">resTag</span><span class="s3">, </span><span class="s2">&quot;&gt;&quot;</span><span class="s1">]</span>
1034 <a name="l1014"><span class="ln">1014 </span></a>
1035 <a name="l1015"><span class="ln">1015 </span></a>        <span class="s1">out += [nl</span><span class="s3">, </span><span class="s1">indent</span><span class="s3">, </span><span class="s2">&quot;&lt;/&quot;</span><span class="s3">, </span><span class="s1">selfTag</span><span class="s3">, </span><span class="s2">&quot;&gt;&quot;</span><span class="s1">]</span>
1036 <a name="l1016"><span class="ln">1016 </span></a>        <span class="s3">return </span><span class="s2">&quot;&quot;</span><span class="s1">.join(out)</span>
1037 <a name="l1017"><span class="ln">1017 </span></a>
1038 <a name="l1018"><span class="ln">1018 </span></a>    <span class="s3">def </span><span class="s1">__lookup(self</span><span class="s3">, </span><span class="s1">sub):</span>
1039 <a name="l1019"><span class="ln">1019 </span></a>        <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">vlist </span><span class="s3">in </span><span class="s1">self.__tokdict.items():</span>
1040 <a name="l1020"><span class="ln">1020 </span></a>            <span class="s3">for </span><span class="s1">v</span><span class="s3">, </span><span class="s1">loc </span><span class="s3">in </span><span class="s1">vlist:</span>
1041 <a name="l1021"><span class="ln">1021 </span></a>                <span class="s3">if </span><span class="s1">sub </span><span class="s3">is </span><span class="s1">v:</span>
1042 <a name="l1022"><span class="ln">1022 </span></a>                    <span class="s3">return </span><span class="s1">k</span>
1043 <a name="l1023"><span class="ln">1023 </span></a>        <span class="s3">return None</span>
1044 <a name="l1024"><span class="ln">1024 </span></a>
1045 <a name="l1025"><span class="ln">1025 </span></a>    <span class="s3">def </span><span class="s1">getName(self):</span>
1046 <a name="l1026"><span class="ln">1026 </span></a>        <span class="s5">r&quot;&quot;&quot; 
1047 <a name="l1027"><span class="ln">1027 </span></a>        Returns the results name for this token expression. Useful when several 
1048 <a name="l1028"><span class="ln">1028 </span></a>        different expressions might match at a particular location. 
1049 <a name="l1029"><span class="ln">1029 </span></a> 
1050 <a name="l1030"><span class="ln">1030 </span></a>        Example:: 
1051 <a name="l1031"><span class="ln">1031 </span></a> 
1052 <a name="l1032"><span class="ln">1032 </span></a>            integer = Word(nums) 
1053 <a name="l1033"><span class="ln">1033 </span></a>            ssn_expr = Regex(r&quot;\d\d\d-\d\d-\d\d\d\d&quot;) 
1054 <a name="l1034"><span class="ln">1034 </span></a>            house_number_expr = Suppress('#') + Word(nums, alphanums) 
1055 <a name="l1035"><span class="ln">1035 </span></a>            user_data = (Group(house_number_expr)(&quot;house_number&quot;) 
1056 <a name="l1036"><span class="ln">1036 </span></a>                        | Group(ssn_expr)(&quot;ssn&quot;) 
1057 <a name="l1037"><span class="ln">1037 </span></a>                        | Group(integer)(&quot;age&quot;)) 
1058 <a name="l1038"><span class="ln">1038 </span></a>            user_info = OneOrMore(user_data) 
1059 <a name="l1039"><span class="ln">1039 </span></a> 
1060 <a name="l1040"><span class="ln">1040 </span></a>            result = user_info.parseString(&quot;22 111-22-3333 #221B&quot;) 
1061 <a name="l1041"><span class="ln">1041 </span></a>            for item in result: 
1062 <a name="l1042"><span class="ln">1042 </span></a>                print(item.getName(), ':', item[0]) 
1063 <a name="l1043"><span class="ln">1043 </span></a> 
1064 <a name="l1044"><span class="ln">1044 </span></a>        prints:: 
1065 <a name="l1045"><span class="ln">1045 </span></a> 
1066 <a name="l1046"><span class="ln">1046 </span></a>            age : 22 
1067 <a name="l1047"><span class="ln">1047 </span></a>            ssn : 111-22-3333 
1068 <a name="l1048"><span class="ln">1048 </span></a>            house_number : 221B 
1069 <a name="l1049"><span class="ln">1049 </span></a>        &quot;&quot;&quot;</span>
1070 <a name="l1050"><span class="ln">1050 </span></a>        <span class="s3">if </span><span class="s1">self.__name:</span>
1071 <a name="l1051"><span class="ln">1051 </span></a>            <span class="s3">return </span><span class="s1">self.__name</span>
1072 <a name="l1052"><span class="ln">1052 </span></a>        <span class="s3">elif </span><span class="s1">self.__parent:</span>
1073 <a name="l1053"><span class="ln">1053 </span></a>            <span class="s1">par = self.__parent()</span>
1074 <a name="l1054"><span class="ln">1054 </span></a>            <span class="s3">if </span><span class="s1">par:</span>
1075 <a name="l1055"><span class="ln">1055 </span></a>                <span class="s3">return </span><span class="s1">par.__lookup(self)</span>
1076 <a name="l1056"><span class="ln">1056 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1077 <a name="l1057"><span class="ln">1057 </span></a>                <span class="s3">return None</span>
1078 <a name="l1058"><span class="ln">1058 </span></a>        <span class="s3">elif </span><span class="s1">(len(self) == </span><span class="s4">1</span>
1079 <a name="l1059"><span class="ln">1059 </span></a>              <span class="s3">and </span><span class="s1">len(self.__tokdict) == </span><span class="s4">1</span>
1080 <a name="l1060"><span class="ln">1060 </span></a>              <span class="s3">and </span><span class="s1">next(iter(self.__tokdict.values()))[</span><span class="s4">0</span><span class="s1">][</span><span class="s4">1</span><span class="s1">] </span><span class="s3">in </span><span class="s1">(</span><span class="s4">0</span><span class="s3">, </span><span class="s1">-</span><span class="s4">1</span><span class="s1">)):</span>
1081 <a name="l1061"><span class="ln">1061 </span></a>            <span class="s3">return </span><span class="s1">next(iter(self.__tokdict.keys()))</span>
1082 <a name="l1062"><span class="ln">1062 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1083 <a name="l1063"><span class="ln">1063 </span></a>            <span class="s3">return None</span>
1084 <a name="l1064"><span class="ln">1064 </span></a>
1085 <a name="l1065"><span class="ln">1065 </span></a>    <span class="s3">def </span><span class="s1">dump(self</span><span class="s3">, </span><span class="s1">indent=</span><span class="s2">''</span><span class="s3">, </span><span class="s1">full=</span><span class="s3">True, </span><span class="s1">include_list=</span><span class="s3">True, </span><span class="s1">_depth=</span><span class="s4">0</span><span class="s1">):</span>
1086 <a name="l1066"><span class="ln">1066 </span></a>        <span class="s5">&quot;&quot;&quot; 
1087 <a name="l1067"><span class="ln">1067 </span></a>        Diagnostic method for listing out the contents of 
1088 <a name="l1068"><span class="ln">1068 </span></a>        a :class:`ParseResults`. Accepts an optional ``indent`` argument so 
1089 <a name="l1069"><span class="ln">1069 </span></a>        that this string can be embedded in a nested display of other data. 
1090 <a name="l1070"><span class="ln">1070 </span></a> 
1091 <a name="l1071"><span class="ln">1071 </span></a>        Example:: 
1092 <a name="l1072"><span class="ln">1072 </span></a> 
1093 <a name="l1073"><span class="ln">1073 </span></a>            integer = Word(nums) 
1094 <a name="l1074"><span class="ln">1074 </span></a>            date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
1095 <a name="l1075"><span class="ln">1075 </span></a> 
1096 <a name="l1076"><span class="ln">1076 </span></a>            result = date_str.parseString('12/31/1999') 
1097 <a name="l1077"><span class="ln">1077 </span></a>            print(result.dump()) 
1098 <a name="l1078"><span class="ln">1078 </span></a> 
1099 <a name="l1079"><span class="ln">1079 </span></a>        prints:: 
1100 <a name="l1080"><span class="ln">1080 </span></a> 
1101 <a name="l1081"><span class="ln">1081 </span></a>            ['12', '/', '31', '/', '1999'] 
1102 <a name="l1082"><span class="ln">1082 </span></a>            - day: 1999 
1103 <a name="l1083"><span class="ln">1083 </span></a>            - month: 31 
1104 <a name="l1084"><span class="ln">1084 </span></a>            - year: 12 
1105 <a name="l1085"><span class="ln">1085 </span></a>        &quot;&quot;&quot;</span>
1106 <a name="l1086"><span class="ln">1086 </span></a>        <span class="s1">out = []</span>
1107 <a name="l1087"><span class="ln">1087 </span></a>        <span class="s1">NL = </span><span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span>
1108 <a name="l1088"><span class="ln">1088 </span></a>        <span class="s3">if </span><span class="s1">include_list:</span>
1109 <a name="l1089"><span class="ln">1089 </span></a>            <span class="s1">out.append(indent + _ustr(self.asList()))</span>
1110 <a name="l1090"><span class="ln">1090 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1111 <a name="l1091"><span class="ln">1091 </span></a>            <span class="s1">out.append(</span><span class="s2">''</span><span class="s1">)</span>
1112 <a name="l1092"><span class="ln">1092 </span></a>
1113 <a name="l1093"><span class="ln">1093 </span></a>        <span class="s3">if </span><span class="s1">full:</span>
1114 <a name="l1094"><span class="ln">1094 </span></a>            <span class="s3">if </span><span class="s1">self.haskeys():</span>
1115 <a name="l1095"><span class="ln">1095 </span></a>                <span class="s1">items = sorted((str(k)</span><span class="s3">, </span><span class="s1">v) </span><span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">self.items())</span>
1116 <a name="l1096"><span class="ln">1096 </span></a>                <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">items:</span>
1117 <a name="l1097"><span class="ln">1097 </span></a>                    <span class="s3">if </span><span class="s1">out:</span>
1118 <a name="l1098"><span class="ln">1098 </span></a>                        <span class="s1">out.append(NL)</span>
1119 <a name="l1099"><span class="ln">1099 </span></a>                    <span class="s1">out.append(</span><span class="s2">&quot;%s%s- %s: &quot; </span><span class="s1">% (indent</span><span class="s3">, </span><span class="s1">(</span><span class="s2">'  ' </span><span class="s1">* _depth)</span><span class="s3">, </span><span class="s1">k))</span>
1120 <a name="l1100"><span class="ln">1100 </span></a>                    <span class="s3">if </span><span class="s1">isinstance(v</span><span class="s3">, </span><span class="s1">ParseResults):</span>
1121 <a name="l1101"><span class="ln">1101 </span></a>                        <span class="s3">if </span><span class="s1">v:</span>
1122 <a name="l1102"><span class="ln">1102 </span></a>                            <span class="s1">out.append(v.dump(indent=indent</span><span class="s3">, </span><span class="s1">full=full</span><span class="s3">, </span><span class="s1">include_list=include_list</span><span class="s3">, </span><span class="s1">_depth=_depth + </span><span class="s4">1</span><span class="s1">))</span>
1123 <a name="l1103"><span class="ln">1103 </span></a>                        <span class="s3">else</span><span class="s1">:</span>
1124 <a name="l1104"><span class="ln">1104 </span></a>                            <span class="s1">out.append(_ustr(v))</span>
1125 <a name="l1105"><span class="ln">1105 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
1126 <a name="l1106"><span class="ln">1106 </span></a>                        <span class="s1">out.append(repr(v))</span>
1127 <a name="l1107"><span class="ln">1107 </span></a>            <span class="s3">elif </span><span class="s1">any(isinstance(vv</span><span class="s3">, </span><span class="s1">ParseResults) </span><span class="s3">for </span><span class="s1">vv </span><span class="s3">in </span><span class="s1">self):</span>
1128 <a name="l1108"><span class="ln">1108 </span></a>                <span class="s1">v = self</span>
1129 <a name="l1109"><span class="ln">1109 </span></a>                <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">vv </span><span class="s3">in </span><span class="s1">enumerate(v):</span>
1130 <a name="l1110"><span class="ln">1110 </span></a>                    <span class="s3">if </span><span class="s1">isinstance(vv</span><span class="s3">, </span><span class="s1">ParseResults):</span>
1131 <a name="l1111"><span class="ln">1111 </span></a>                        <span class="s1">out.append(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">%s%s[%d]:</span><span class="s3">\n</span><span class="s2">%s%s%s&quot; </span><span class="s1">% (indent</span><span class="s3">,</span>
1132 <a name="l1112"><span class="ln">1112 </span></a>                                                            <span class="s1">(</span><span class="s2">'  ' </span><span class="s1">* (_depth))</span><span class="s3">,</span>
1133 <a name="l1113"><span class="ln">1113 </span></a>                                                            <span class="s1">i</span><span class="s3">,</span>
1134 <a name="l1114"><span class="ln">1114 </span></a>                                                            <span class="s1">indent</span><span class="s3">,</span>
1135 <a name="l1115"><span class="ln">1115 </span></a>                                                            <span class="s1">(</span><span class="s2">'  ' </span><span class="s1">* (_depth + </span><span class="s4">1</span><span class="s1">))</span><span class="s3">,</span>
1136 <a name="l1116"><span class="ln">1116 </span></a>                                                            <span class="s1">vv.dump(indent=indent</span><span class="s3">,</span>
1137 <a name="l1117"><span class="ln">1117 </span></a>                                                                    <span class="s1">full=full</span><span class="s3">,</span>
1138 <a name="l1118"><span class="ln">1118 </span></a>                                                                    <span class="s1">include_list=include_list</span><span class="s3">,</span>
1139 <a name="l1119"><span class="ln">1119 </span></a>                                                                    <span class="s1">_depth=_depth + </span><span class="s4">1</span><span class="s1">)))</span>
1140 <a name="l1120"><span class="ln">1120 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
1141 <a name="l1121"><span class="ln">1121 </span></a>                        <span class="s1">out.append(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">%s%s[%d]:</span><span class="s3">\n</span><span class="s2">%s%s%s&quot; </span><span class="s1">% (indent</span><span class="s3">,</span>
1142 <a name="l1122"><span class="ln">1122 </span></a>                                                            <span class="s1">(</span><span class="s2">'  ' </span><span class="s1">* (_depth))</span><span class="s3">,</span>
1143 <a name="l1123"><span class="ln">1123 </span></a>                                                            <span class="s1">i</span><span class="s3">,</span>
1144 <a name="l1124"><span class="ln">1124 </span></a>                                                            <span class="s1">indent</span><span class="s3">,</span>
1145 <a name="l1125"><span class="ln">1125 </span></a>                                                            <span class="s1">(</span><span class="s2">'  ' </span><span class="s1">* (_depth + </span><span class="s4">1</span><span class="s1">))</span><span class="s3">,</span>
1146 <a name="l1126"><span class="ln">1126 </span></a>                                                            <span class="s1">_ustr(vv)))</span>
1147 <a name="l1127"><span class="ln">1127 </span></a>
1148 <a name="l1128"><span class="ln">1128 </span></a>        <span class="s3">return </span><span class="s2">&quot;&quot;</span><span class="s1">.join(out)</span>
1149 <a name="l1129"><span class="ln">1129 </span></a>
1150 <a name="l1130"><span class="ln">1130 </span></a>    <span class="s3">def </span><span class="s1">pprint(self</span><span class="s3">, </span><span class="s1">*args</span><span class="s3">, </span><span class="s1">**kwargs):</span>
1151 <a name="l1131"><span class="ln">1131 </span></a>        <span class="s5">&quot;&quot;&quot; 
1152 <a name="l1132"><span class="ln">1132 </span></a>        Pretty-printer for parsed results as a list, using the 
1153 <a name="l1133"><span class="ln">1133 </span></a>        `pprint &lt;https://docs.python.org/3/library/pprint.html&gt;`_ module. 
1154 <a name="l1134"><span class="ln">1134 </span></a>        Accepts additional positional or keyword args as defined for 
1155 <a name="l1135"><span class="ln">1135 </span></a>        `pprint.pprint &lt;https://docs.python.org/3/library/pprint.html#pprint.pprint&gt;`_ . 
1156 <a name="l1136"><span class="ln">1136 </span></a> 
1157 <a name="l1137"><span class="ln">1137 </span></a>        Example:: 
1158 <a name="l1138"><span class="ln">1138 </span></a> 
1159 <a name="l1139"><span class="ln">1139 </span></a>            ident = Word(alphas, alphanums) 
1160 <a name="l1140"><span class="ln">1140 </span></a>            num = Word(nums) 
1161 <a name="l1141"><span class="ln">1141 </span></a>            func = Forward() 
1162 <a name="l1142"><span class="ln">1142 </span></a>            term = ident | num | Group('(' + func + ')') 
1163 <a name="l1143"><span class="ln">1143 </span></a>            func &lt;&lt;= ident + Group(Optional(delimitedList(term))) 
1164 <a name="l1144"><span class="ln">1144 </span></a>            result = func.parseString(&quot;fna a,b,(fnb c,d,200),100&quot;) 
1165 <a name="l1145"><span class="ln">1145 </span></a>            result.pprint(width=40) 
1166 <a name="l1146"><span class="ln">1146 </span></a> 
1167 <a name="l1147"><span class="ln">1147 </span></a>        prints:: 
1168 <a name="l1148"><span class="ln">1148 </span></a> 
1169 <a name="l1149"><span class="ln">1149 </span></a>            ['fna', 
1170 <a name="l1150"><span class="ln">1150 </span></a>             ['a', 
1171 <a name="l1151"><span class="ln">1151 </span></a>              'b', 
1172 <a name="l1152"><span class="ln">1152 </span></a>              ['(', 'fnb', ['c', 'd', '200'], ')'], 
1173 <a name="l1153"><span class="ln">1153 </span></a>              '100']] 
1174 <a name="l1154"><span class="ln">1154 </span></a>        &quot;&quot;&quot;</span>
1175 <a name="l1155"><span class="ln">1155 </span></a>        <span class="s1">pprint.pprint(self.asList()</span><span class="s3">, </span><span class="s1">*args</span><span class="s3">, </span><span class="s1">**kwargs)</span>
1176 <a name="l1156"><span class="ln">1156 </span></a>
1177 <a name="l1157"><span class="ln">1157 </span></a>    <span class="s0"># add support for pickle protocol</span>
1178 <a name="l1158"><span class="ln">1158 </span></a>    <span class="s3">def </span><span class="s1">__getstate__(self):</span>
1179 <a name="l1159"><span class="ln">1159 </span></a>        <span class="s3">return </span><span class="s1">(self.__toklist</span><span class="s3">,</span>
1180 <a name="l1160"><span class="ln">1160 </span></a>                <span class="s1">(self.__tokdict.copy()</span><span class="s3">,</span>
1181 <a name="l1161"><span class="ln">1161 </span></a>                 <span class="s1">self.__parent </span><span class="s3">is not None and </span><span class="s1">self.__parent() </span><span class="s3">or None,</span>
1182 <a name="l1162"><span class="ln">1162 </span></a>                 <span class="s1">self.__accumNames</span><span class="s3">,</span>
1183 <a name="l1163"><span class="ln">1163 </span></a>                 <span class="s1">self.__name))</span>
1184 <a name="l1164"><span class="ln">1164 </span></a>
1185 <a name="l1165"><span class="ln">1165 </span></a>    <span class="s3">def </span><span class="s1">__setstate__(self</span><span class="s3">, </span><span class="s1">state):</span>
1186 <a name="l1166"><span class="ln">1166 </span></a>        <span class="s1">self.__toklist = state[</span><span class="s4">0</span><span class="s1">]</span>
1187 <a name="l1167"><span class="ln">1167 </span></a>        <span class="s1">self.__tokdict</span><span class="s3">, </span><span class="s1">par</span><span class="s3">, </span><span class="s1">inAccumNames</span><span class="s3">, </span><span class="s1">self.__name = state[</span><span class="s4">1</span><span class="s1">]</span>
1188 <a name="l1168"><span class="ln">1168 </span></a>        <span class="s1">self.__accumNames = {}</span>
1189 <a name="l1169"><span class="ln">1169 </span></a>        <span class="s1">self.__accumNames.update(inAccumNames)</span>
1190 <a name="l1170"><span class="ln">1170 </span></a>        <span class="s3">if </span><span class="s1">par </span><span class="s3">is not None</span><span class="s1">:</span>
1191 <a name="l1171"><span class="ln">1171 </span></a>            <span class="s1">self.__parent = wkref(par)</span>
1192 <a name="l1172"><span class="ln">1172 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1193 <a name="l1173"><span class="ln">1173 </span></a>            <span class="s1">self.__parent = </span><span class="s3">None</span>
1194 <a name="l1174"><span class="ln">1174 </span></a>
1195 <a name="l1175"><span class="ln">1175 </span></a>    <span class="s3">def </span><span class="s1">__getnewargs__(self):</span>
1196 <a name="l1176"><span class="ln">1176 </span></a>        <span class="s3">return </span><span class="s1">self.__toklist</span><span class="s3">, </span><span class="s1">self.__name</span><span class="s3">, </span><span class="s1">self.__asList</span><span class="s3">, </span><span class="s1">self.__modal</span>
1197 <a name="l1177"><span class="ln">1177 </span></a>
1198 <a name="l1178"><span class="ln">1178 </span></a>    <span class="s3">def </span><span class="s1">__dir__(self):</span>
1199 <a name="l1179"><span class="ln">1179 </span></a>        <span class="s3">return </span><span class="s1">dir(type(self)) + list(self.keys())</span>
1200 <a name="l1180"><span class="ln">1180 </span></a>
1201 <a name="l1181"><span class="ln">1181 </span></a>    <span class="s1">@classmethod</span>
1202 <a name="l1182"><span class="ln">1182 </span></a>    <span class="s3">def </span><span class="s1">from_dict(cls</span><span class="s3">, </span><span class="s1">other</span><span class="s3">, </span><span class="s1">name=</span><span class="s3">None</span><span class="s1">):</span>
1203 <a name="l1183"><span class="ln">1183 </span></a>        <span class="s5">&quot;&quot;&quot; 
1204 <a name="l1184"><span class="ln">1184 </span></a>        Helper classmethod to construct a ParseResults from a dict, preserving the 
1205 <a name="l1185"><span class="ln">1185 </span></a>        name-value relations as results names. If an optional 'name' argument is 
1206 <a name="l1186"><span class="ln">1186 </span></a>        given, a nested ParseResults will be returned 
1207 <a name="l1187"><span class="ln">1187 </span></a>        &quot;&quot;&quot;</span>
1208 <a name="l1188"><span class="ln">1188 </span></a>        <span class="s3">def </span><span class="s1">is_iterable(obj):</span>
1209 <a name="l1189"><span class="ln">1189 </span></a>            <span class="s3">try</span><span class="s1">:</span>
1210 <a name="l1190"><span class="ln">1190 </span></a>                <span class="s1">iter(obj)</span>
1211 <a name="l1191"><span class="ln">1191 </span></a>            <span class="s3">except </span><span class="s1">Exception:</span>
1212 <a name="l1192"><span class="ln">1192 </span></a>                <span class="s3">return False</span>
1213 <a name="l1193"><span class="ln">1193 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1214 <a name="l1194"><span class="ln">1194 </span></a>                <span class="s3">if </span><span class="s1">PY_3:</span>
1215 <a name="l1195"><span class="ln">1195 </span></a>                    <span class="s3">return not </span><span class="s1">isinstance(obj</span><span class="s3">, </span><span class="s1">(str</span><span class="s3">, </span><span class="s1">bytes))</span>
1216 <a name="l1196"><span class="ln">1196 </span></a>                <span class="s3">else</span><span class="s1">:</span>
1217 <a name="l1197"><span class="ln">1197 </span></a>                    <span class="s3">return not </span><span class="s1">isinstance(obj</span><span class="s3">, </span><span class="s1">basestring)</span>
1218 <a name="l1198"><span class="ln">1198 </span></a>
1219 <a name="l1199"><span class="ln">1199 </span></a>        <span class="s1">ret = cls([])</span>
1220 <a name="l1200"><span class="ln">1200 </span></a>        <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">other.items():</span>
1221 <a name="l1201"><span class="ln">1201 </span></a>            <span class="s3">if </span><span class="s1">isinstance(v</span><span class="s3">, </span><span class="s1">Mapping):</span>
1222 <a name="l1202"><span class="ln">1202 </span></a>                <span class="s1">ret += cls.from_dict(v</span><span class="s3">, </span><span class="s1">name=k)</span>
1223 <a name="l1203"><span class="ln">1203 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1224 <a name="l1204"><span class="ln">1204 </span></a>                <span class="s1">ret += cls([v]</span><span class="s3">, </span><span class="s1">name=k</span><span class="s3">, </span><span class="s1">asList=is_iterable(v))</span>
1225 <a name="l1205"><span class="ln">1205 </span></a>        <span class="s3">if </span><span class="s1">name </span><span class="s3">is not None</span><span class="s1">:</span>
1226 <a name="l1206"><span class="ln">1206 </span></a>            <span class="s1">ret = cls([ret]</span><span class="s3">, </span><span class="s1">name=name)</span>
1227 <a name="l1207"><span class="ln">1207 </span></a>        <span class="s3">return </span><span class="s1">ret</span>
1228 <a name="l1208"><span class="ln">1208 </span></a>
1229 <a name="l1209"><span class="ln">1209 </span></a><span class="s1">MutableMapping.register(ParseResults)</span>
1230 <a name="l1210"><span class="ln">1210 </span></a>
1231 <a name="l1211"><span class="ln">1211 </span></a><span class="s3">def </span><span class="s1">col (loc</span><span class="s3">, </span><span class="s1">strg):</span>
1232 <a name="l1212"><span class="ln">1212 </span></a>    <span class="s5">&quot;&quot;&quot;Returns current column within a string, counting newlines as line separators. 
1233 <a name="l1213"><span class="ln">1213 </span></a>   The first column is number 1. 
1234 <a name="l1214"><span class="ln">1214 </span></a> 
1235 <a name="l1215"><span class="ln">1215 </span></a>   Note: the default parsing behavior is to expand tabs in the input string 
1236 <a name="l1216"><span class="ln">1216 </span></a>   before starting the parsing process.  See 
1237 <a name="l1217"><span class="ln">1217 </span></a>   :class:`ParserElement.parseString` for more 
1238 <a name="l1218"><span class="ln">1218 </span></a>   information on parsing strings containing ``&lt;TAB&gt;`` s, and suggested 
1239 <a name="l1219"><span class="ln">1219 </span></a>   methods to maintain a consistent view of the parsed string, the parse 
1240 <a name="l1220"><span class="ln">1220 </span></a>   location, and line and column positions within the parsed string. 
1241 <a name="l1221"><span class="ln">1221 </span></a>   &quot;&quot;&quot;</span>
1242 <a name="l1222"><span class="ln">1222 </span></a>    <span class="s1">s = strg</span>
1243 <a name="l1223"><span class="ln">1223 </span></a>    <span class="s3">return </span><span class="s4">1 </span><span class="s3">if </span><span class="s4">0 </span><span class="s1">&lt; loc &lt; len(s) </span><span class="s3">and </span><span class="s1">s[loc-</span><span class="s4">1</span><span class="s1">] == </span><span class="s2">'</span><span class="s3">\n</span><span class="s2">' </span><span class="s3">else </span><span class="s1">loc - s.rfind(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s4">0</span><span class="s3">, </span><span class="s1">loc)</span>
1244 <a name="l1224"><span class="ln">1224 </span></a>
1245 <a name="l1225"><span class="ln">1225 </span></a><span class="s3">def </span><span class="s1">lineno(loc</span><span class="s3">, </span><span class="s1">strg):</span>
1246 <a name="l1226"><span class="ln">1226 </span></a>    <span class="s5">&quot;&quot;&quot;Returns current line number within a string, counting newlines as line separators. 
1247 <a name="l1227"><span class="ln">1227 </span></a>    The first line is number 1. 
1248 <a name="l1228"><span class="ln">1228 </span></a> 
1249 <a name="l1229"><span class="ln">1229 </span></a>    Note - the default parsing behavior is to expand tabs in the input string 
1250 <a name="l1230"><span class="ln">1230 </span></a>    before starting the parsing process.  See :class:`ParserElement.parseString` 
1251 <a name="l1231"><span class="ln">1231 </span></a>    for more information on parsing strings containing ``&lt;TAB&gt;`` s, and 
1252 <a name="l1232"><span class="ln">1232 </span></a>    suggested methods to maintain a consistent view of the parsed string, the 
1253 <a name="l1233"><span class="ln">1233 </span></a>    parse location, and line and column positions within the parsed string. 
1254 <a name="l1234"><span class="ln">1234 </span></a>    &quot;&quot;&quot;</span>
1255 <a name="l1235"><span class="ln">1235 </span></a>    <span class="s3">return </span><span class="s1">strg.count(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s4">0</span><span class="s3">, </span><span class="s1">loc) + </span><span class="s4">1</span>
1256 <a name="l1236"><span class="ln">1236 </span></a>
1257 <a name="l1237"><span class="ln">1237 </span></a><span class="s3">def </span><span class="s1">line(loc</span><span class="s3">, </span><span class="s1">strg):</span>
1258 <a name="l1238"><span class="ln">1238 </span></a>    <span class="s5">&quot;&quot;&quot;Returns the line of text containing loc within a string, counting newlines as line separators. 
1259 <a name="l1239"><span class="ln">1239 </span></a>       &quot;&quot;&quot;</span>
1260 <a name="l1240"><span class="ln">1240 </span></a>    <span class="s1">lastCR = strg.rfind(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s4">0</span><span class="s3">, </span><span class="s1">loc)</span>
1261 <a name="l1241"><span class="ln">1241 </span></a>    <span class="s1">nextCR = strg.find(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s1">loc)</span>
1262 <a name="l1242"><span class="ln">1242 </span></a>    <span class="s3">if </span><span class="s1">nextCR &gt;= </span><span class="s4">0</span><span class="s1">:</span>
1263 <a name="l1243"><span class="ln">1243 </span></a>        <span class="s3">return </span><span class="s1">strg[lastCR + </span><span class="s4">1</span><span class="s1">:nextCR]</span>
1264 <a name="l1244"><span class="ln">1244 </span></a>    <span class="s3">else</span><span class="s1">:</span>
1265 <a name="l1245"><span class="ln">1245 </span></a>        <span class="s3">return </span><span class="s1">strg[lastCR + </span><span class="s4">1</span><span class="s1">:]</span>
1266 <a name="l1246"><span class="ln">1246 </span></a>
1267 <a name="l1247"><span class="ln">1247 </span></a><span class="s3">def </span><span class="s1">_defaultStartDebugAction(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">expr):</span>
1268 <a name="l1248"><span class="ln">1248 </span></a>    <span class="s1">print((</span><span class="s2">&quot;Match &quot; </span><span class="s1">+ _ustr(expr) + </span><span class="s2">&quot; at loc &quot; </span><span class="s1">+ _ustr(loc) + </span><span class="s2">&quot;(%d,%d)&quot; </span><span class="s1">% (lineno(loc</span><span class="s3">, </span><span class="s1">instring)</span><span class="s3">, </span><span class="s1">col(loc</span><span class="s3">, </span><span class="s1">instring))))</span>
1269 <a name="l1249"><span class="ln">1249 </span></a>
1270 <a name="l1250"><span class="ln">1250 </span></a><span class="s3">def </span><span class="s1">_defaultSuccessDebugAction(instring</span><span class="s3">, </span><span class="s1">startloc</span><span class="s3">, </span><span class="s1">endloc</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">toks):</span>
1271 <a name="l1251"><span class="ln">1251 </span></a>    <span class="s1">print(</span><span class="s2">&quot;Matched &quot; </span><span class="s1">+ _ustr(expr) + </span><span class="s2">&quot; -&gt; &quot; </span><span class="s1">+ str(toks.asList()))</span>
1272 <a name="l1252"><span class="ln">1252 </span></a>
1273 <a name="l1253"><span class="ln">1253 </span></a><span class="s3">def </span><span class="s1">_defaultExceptionDebugAction(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">exc):</span>
1274 <a name="l1254"><span class="ln">1254 </span></a>    <span class="s1">print(</span><span class="s2">&quot;Exception raised:&quot; </span><span class="s1">+ _ustr(exc))</span>
1275 <a name="l1255"><span class="ln">1255 </span></a>
1276 <a name="l1256"><span class="ln">1256 </span></a><span class="s3">def </span><span class="s1">nullDebugAction(*args):</span>
1277 <a name="l1257"><span class="ln">1257 </span></a>    <span class="s5">&quot;&quot;&quot;'Do-nothing' debug action, to suppress debugging output during parsing.&quot;&quot;&quot;</span>
1278 <a name="l1258"><span class="ln">1258 </span></a>    <span class="s3">pass</span>
1279 <a name="l1259"><span class="ln">1259 </span></a>
1280 <a name="l1260"><span class="ln">1260 </span></a><span class="s0"># Only works on Python 3.x - nonlocal is toxic to Python 2 installs</span>
1281 <a name="l1261"><span class="ln">1261 </span></a><span class="s0">#~ 'decorator to trim function calls to match the arity of the target'</span>
1282 <a name="l1262"><span class="ln">1262 </span></a><span class="s0">#~ def _trim_arity(func, maxargs=3):</span>
1283 <a name="l1263"><span class="ln">1263 </span></a>    <span class="s0">#~ if func in singleArgBuiltins:</span>
1284 <a name="l1264"><span class="ln">1264 </span></a>        <span class="s0">#~ return lambda s,l,t: func(t)</span>
1285 <a name="l1265"><span class="ln">1265 </span></a>    <span class="s0">#~ limit = 0</span>
1286 <a name="l1266"><span class="ln">1266 </span></a>    <span class="s0">#~ foundArity = False</span>
1287 <a name="l1267"><span class="ln">1267 </span></a>    <span class="s0">#~ def wrapper(*args):</span>
1288 <a name="l1268"><span class="ln">1268 </span></a>        <span class="s0">#~ nonlocal limit,foundArity</span>
1289 <a name="l1269"><span class="ln">1269 </span></a>        <span class="s0">#~ while 1:</span>
1290 <a name="l1270"><span class="ln">1270 </span></a>            <span class="s0">#~ try:</span>
1291 <a name="l1271"><span class="ln">1271 </span></a>                <span class="s0">#~ ret = func(*args[limit:])</span>
1292 <a name="l1272"><span class="ln">1272 </span></a>                <span class="s0">#~ foundArity = True</span>
1293 <a name="l1273"><span class="ln">1273 </span></a>                <span class="s0">#~ return ret</span>
1294 <a name="l1274"><span class="ln">1274 </span></a>            <span class="s0">#~ except TypeError:</span>
1295 <a name="l1275"><span class="ln">1275 </span></a>                <span class="s0">#~ if limit == maxargs or foundArity:</span>
1296 <a name="l1276"><span class="ln">1276 </span></a>                    <span class="s0">#~ raise</span>
1297 <a name="l1277"><span class="ln">1277 </span></a>                <span class="s0">#~ limit += 1</span>
1298 <a name="l1278"><span class="ln">1278 </span></a>                <span class="s0">#~ continue</span>
1299 <a name="l1279"><span class="ln">1279 </span></a>    <span class="s0">#~ return wrapper</span>
1300 <a name="l1280"><span class="ln">1280 </span></a>
1301 <a name="l1281"><span class="ln">1281 </span></a><span class="s0"># this version is Python 2.x-3.x cross-compatible</span>
1302 <a name="l1282"><span class="ln">1282 </span></a><span class="s2">'decorator to trim function calls to match the arity of the target'</span>
1303 <a name="l1283"><span class="ln">1283 </span></a><span class="s3">def </span><span class="s1">_trim_arity(func</span><span class="s3">, </span><span class="s1">maxargs=</span><span class="s4">2</span><span class="s1">):</span>
1304 <a name="l1284"><span class="ln">1284 </span></a>    <span class="s3">if </span><span class="s1">func </span><span class="s3">in </span><span class="s1">singleArgBuiltins:</span>
1305 <a name="l1285"><span class="ln">1285 </span></a>        <span class="s3">return lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: func(t)</span>
1306 <a name="l1286"><span class="ln">1286 </span></a>    <span class="s1">limit = [</span><span class="s4">0</span><span class="s1">]</span>
1307 <a name="l1287"><span class="ln">1287 </span></a>    <span class="s1">foundArity = [</span><span class="s3">False</span><span class="s1">]</span>
1308 <a name="l1288"><span class="ln">1288 </span></a>
1309 <a name="l1289"><span class="ln">1289 </span></a>    <span class="s0"># traceback return data structure changed in Py3.5 - normalize back to plain tuples</span>
1310 <a name="l1290"><span class="ln">1290 </span></a>    <span class="s3">if </span><span class="s1">system_version[:</span><span class="s4">2</span><span class="s1">] &gt;= (</span><span class="s4">3</span><span class="s3">, </span><span class="s4">5</span><span class="s1">):</span>
1311 <a name="l1291"><span class="ln">1291 </span></a>        <span class="s3">def </span><span class="s1">extract_stack(limit=</span><span class="s4">0</span><span class="s1">):</span>
1312 <a name="l1292"><span class="ln">1292 </span></a>            <span class="s0"># special handling for Python 3.5.0 - extra deep call stack by 1</span>
1313 <a name="l1293"><span class="ln">1293 </span></a>            <span class="s1">offset = -</span><span class="s4">3 </span><span class="s3">if </span><span class="s1">system_version == (</span><span class="s4">3</span><span class="s3">, </span><span class="s4">5</span><span class="s3">, </span><span class="s4">0</span><span class="s1">) </span><span class="s3">else </span><span class="s1">-</span><span class="s4">2</span>
1314 <a name="l1294"><span class="ln">1294 </span></a>            <span class="s1">frame_summary = traceback.extract_stack(limit=-offset + limit - </span><span class="s4">1</span><span class="s1">)[offset]</span>
1315 <a name="l1295"><span class="ln">1295 </span></a>            <span class="s3">return </span><span class="s1">[frame_summary[:</span><span class="s4">2</span><span class="s1">]]</span>
1316 <a name="l1296"><span class="ln">1296 </span></a>        <span class="s3">def </span><span class="s1">extract_tb(tb</span><span class="s3">, </span><span class="s1">limit=</span><span class="s4">0</span><span class="s1">):</span>
1317 <a name="l1297"><span class="ln">1297 </span></a>            <span class="s1">frames = traceback.extract_tb(tb</span><span class="s3">, </span><span class="s1">limit=limit)</span>
1318 <a name="l1298"><span class="ln">1298 </span></a>            <span class="s1">frame_summary = frames[-</span><span class="s4">1</span><span class="s1">]</span>
1319 <a name="l1299"><span class="ln">1299 </span></a>            <span class="s3">return </span><span class="s1">[frame_summary[:</span><span class="s4">2</span><span class="s1">]]</span>
1320 <a name="l1300"><span class="ln">1300 </span></a>    <span class="s3">else</span><span class="s1">:</span>
1321 <a name="l1301"><span class="ln">1301 </span></a>        <span class="s1">extract_stack = traceback.extract_stack</span>
1322 <a name="l1302"><span class="ln">1302 </span></a>        <span class="s1">extract_tb = traceback.extract_tb</span>
1323 <a name="l1303"><span class="ln">1303 </span></a>
1324 <a name="l1304"><span class="ln">1304 </span></a>    <span class="s0"># synthesize what would be returned by traceback.extract_stack at the call to</span>
1325 <a name="l1305"><span class="ln">1305 </span></a>    <span class="s0"># user's parse action 'func', so that we don't incur call penalty at parse time</span>
1326 <a name="l1306"><span class="ln">1306 </span></a>
1327 <a name="l1307"><span class="ln">1307 </span></a>    <span class="s1">LINE_DIFF = </span><span class="s4">6</span>
1328 <a name="l1308"><span class="ln">1308 </span></a>    <span class="s0"># IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND</span>
1329 <a name="l1309"><span class="ln">1309 </span></a>    <span class="s0"># THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!</span>
1330 <a name="l1310"><span class="ln">1310 </span></a>    <span class="s1">this_line = extract_stack(limit=</span><span class="s4">2</span><span class="s1">)[-</span><span class="s4">1</span><span class="s1">]</span>
1331 <a name="l1311"><span class="ln">1311 </span></a>    <span class="s1">pa_call_line_synth = (this_line[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">this_line[</span><span class="s4">1</span><span class="s1">] + LINE_DIFF)</span>
1332 <a name="l1312"><span class="ln">1312 </span></a>
1333 <a name="l1313"><span class="ln">1313 </span></a>    <span class="s3">def </span><span class="s1">wrapper(*args):</span>
1334 <a name="l1314"><span class="ln">1314 </span></a>        <span class="s3">while </span><span class="s4">1</span><span class="s1">:</span>
1335 <a name="l1315"><span class="ln">1315 </span></a>            <span class="s3">try</span><span class="s1">:</span>
1336 <a name="l1316"><span class="ln">1316 </span></a>                <span class="s1">ret = func(*args[limit[</span><span class="s4">0</span><span class="s1">]:])</span>
1337 <a name="l1317"><span class="ln">1317 </span></a>                <span class="s1">foundArity[</span><span class="s4">0</span><span class="s1">] = </span><span class="s3">True</span>
1338 <a name="l1318"><span class="ln">1318 </span></a>                <span class="s3">return </span><span class="s1">ret</span>
1339 <a name="l1319"><span class="ln">1319 </span></a>            <span class="s3">except </span><span class="s1">TypeError:</span>
1340 <a name="l1320"><span class="ln">1320 </span></a>                <span class="s0"># re-raise TypeErrors if they did not come from our arity testing</span>
1341 <a name="l1321"><span class="ln">1321 </span></a>                <span class="s3">if </span><span class="s1">foundArity[</span><span class="s4">0</span><span class="s1">]:</span>
1342 <a name="l1322"><span class="ln">1322 </span></a>                    <span class="s3">raise</span>
1343 <a name="l1323"><span class="ln">1323 </span></a>                <span class="s3">else</span><span class="s1">:</span>
1344 <a name="l1324"><span class="ln">1324 </span></a>                    <span class="s3">try</span><span class="s1">:</span>
1345 <a name="l1325"><span class="ln">1325 </span></a>                        <span class="s1">tb = sys.exc_info()[-</span><span class="s4">1</span><span class="s1">]</span>
1346 <a name="l1326"><span class="ln">1326 </span></a>                        <span class="s3">if not </span><span class="s1">extract_tb(tb</span><span class="s3">, </span><span class="s1">limit=</span><span class="s4">2</span><span class="s1">)[-</span><span class="s4">1</span><span class="s1">][:</span><span class="s4">2</span><span class="s1">] == pa_call_line_synth:</span>
1347 <a name="l1327"><span class="ln">1327 </span></a>                            <span class="s3">raise</span>
1348 <a name="l1328"><span class="ln">1328 </span></a>                    <span class="s3">finally</span><span class="s1">:</span>
1349 <a name="l1329"><span class="ln">1329 </span></a>                        <span class="s3">try</span><span class="s1">:</span>
1350 <a name="l1330"><span class="ln">1330 </span></a>                            <span class="s3">del </span><span class="s1">tb</span>
1351 <a name="l1331"><span class="ln">1331 </span></a>                        <span class="s3">except </span><span class="s1">NameError:</span>
1352 <a name="l1332"><span class="ln">1332 </span></a>                            <span class="s3">pass</span>
1353 <a name="l1333"><span class="ln">1333 </span></a>
1354 <a name="l1334"><span class="ln">1334 </span></a>                <span class="s3">if </span><span class="s1">limit[</span><span class="s4">0</span><span class="s1">] &lt;= maxargs:</span>
1355 <a name="l1335"><span class="ln">1335 </span></a>                    <span class="s1">limit[</span><span class="s4">0</span><span class="s1">] += </span><span class="s4">1</span>
1356 <a name="l1336"><span class="ln">1336 </span></a>                    <span class="s3">continue</span>
1357 <a name="l1337"><span class="ln">1337 </span></a>                <span class="s3">raise</span>
1358 <a name="l1338"><span class="ln">1338 </span></a>
1359 <a name="l1339"><span class="ln">1339 </span></a>    <span class="s0"># copy func name to wrapper for sensible debug output</span>
1360 <a name="l1340"><span class="ln">1340 </span></a>    <span class="s1">func_name = </span><span class="s2">&quot;&lt;parse action&gt;&quot;</span>
1361 <a name="l1341"><span class="ln">1341 </span></a>    <span class="s3">try</span><span class="s1">:</span>
1362 <a name="l1342"><span class="ln">1342 </span></a>        <span class="s1">func_name = getattr(func</span><span class="s3">, </span><span class="s2">'__name__'</span><span class="s3">,</span>
1363 <a name="l1343"><span class="ln">1343 </span></a>                            <span class="s1">getattr(func</span><span class="s3">, </span><span class="s2">'__class__'</span><span class="s1">).__name__)</span>
1364 <a name="l1344"><span class="ln">1344 </span></a>    <span class="s3">except </span><span class="s1">Exception:</span>
1365 <a name="l1345"><span class="ln">1345 </span></a>        <span class="s1">func_name = str(func)</span>
1366 <a name="l1346"><span class="ln">1346 </span></a>    <span class="s1">wrapper.__name__ = func_name</span>
1367 <a name="l1347"><span class="ln">1347 </span></a>
1368 <a name="l1348"><span class="ln">1348 </span></a>    <span class="s3">return </span><span class="s1">wrapper</span>
1369 <a name="l1349"><span class="ln">1349 </span></a>
1370 <a name="l1350"><span class="ln">1350 </span></a>
1371 <a name="l1351"><span class="ln">1351 </span></a><span class="s3">class </span><span class="s1">ParserElement(object):</span>
1372 <a name="l1352"><span class="ln">1352 </span></a>    <span class="s5">&quot;&quot;&quot;Abstract base level parser element class.&quot;&quot;&quot;</span>
1373 <a name="l1353"><span class="ln">1353 </span></a>    <span class="s1">DEFAULT_WHITE_CHARS = </span><span class="s2">&quot; </span><span class="s3">\n\t\r</span><span class="s2">&quot;</span>
1374 <a name="l1354"><span class="ln">1354 </span></a>    <span class="s1">verbose_stacktrace = </span><span class="s3">False</span>
1375 <a name="l1355"><span class="ln">1355 </span></a>
1376 <a name="l1356"><span class="ln">1356 </span></a>    <span class="s1">@staticmethod</span>
1377 <a name="l1357"><span class="ln">1357 </span></a>    <span class="s3">def </span><span class="s1">setDefaultWhitespaceChars(chars):</span>
1378 <a name="l1358"><span class="ln">1358 </span></a>        <span class="s5">r&quot;&quot;&quot; 
1379 <a name="l1359"><span class="ln">1359 </span></a>        Overrides the default whitespace chars 
1380 <a name="l1360"><span class="ln">1360 </span></a> 
1381 <a name="l1361"><span class="ln">1361 </span></a>        Example:: 
1382 <a name="l1362"><span class="ln">1362 </span></a> 
1383 <a name="l1363"><span class="ln">1363 </span></a>            # default whitespace chars are space, &lt;TAB&gt; and newline 
1384 <a name="l1364"><span class="ln">1364 </span></a>            OneOrMore(Word(alphas)).parseString(&quot;abc def\nghi jkl&quot;)  # -&gt; ['abc', 'def', 'ghi', 'jkl'] 
1385 <a name="l1365"><span class="ln">1365 </span></a> 
1386 <a name="l1366"><span class="ln">1366 </span></a>            # change to just treat newline as significant 
1387 <a name="l1367"><span class="ln">1367 </span></a>            ParserElement.setDefaultWhitespaceChars(&quot; \t&quot;) 
1388 <a name="l1368"><span class="ln">1368 </span></a>            OneOrMore(Word(alphas)).parseString(&quot;abc def\nghi jkl&quot;)  # -&gt; ['abc', 'def'] 
1389 <a name="l1369"><span class="ln">1369 </span></a>        &quot;&quot;&quot;</span>
1390 <a name="l1370"><span class="ln">1370 </span></a>        <span class="s1">ParserElement.DEFAULT_WHITE_CHARS = chars</span>
1391 <a name="l1371"><span class="ln">1371 </span></a>
1392 <a name="l1372"><span class="ln">1372 </span></a>    <span class="s1">@staticmethod</span>
1393 <a name="l1373"><span class="ln">1373 </span></a>    <span class="s3">def </span><span class="s1">inlineLiteralsUsing(cls):</span>
1394 <a name="l1374"><span class="ln">1374 </span></a>        <span class="s5">&quot;&quot;&quot; 
1395 <a name="l1375"><span class="ln">1375 </span></a>        Set class to be used for inclusion of string literals into a parser. 
1396 <a name="l1376"><span class="ln">1376 </span></a> 
1397 <a name="l1377"><span class="ln">1377 </span></a>        Example:: 
1398 <a name="l1378"><span class="ln">1378 </span></a> 
1399 <a name="l1379"><span class="ln">1379 </span></a>            # default literal class used is Literal 
1400 <a name="l1380"><span class="ln">1380 </span></a>            integer = Word(nums) 
1401 <a name="l1381"><span class="ln">1381 </span></a>            date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
1402 <a name="l1382"><span class="ln">1382 </span></a> 
1403 <a name="l1383"><span class="ln">1383 </span></a>            date_str.parseString(&quot;1999/12/31&quot;)  # -&gt; ['1999', '/', '12', '/', '31'] 
1404 <a name="l1384"><span class="ln">1384 </span></a> 
1405 <a name="l1385"><span class="ln">1385 </span></a> 
1406 <a name="l1386"><span class="ln">1386 </span></a>            # change to Suppress 
1407 <a name="l1387"><span class="ln">1387 </span></a>            ParserElement.inlineLiteralsUsing(Suppress) 
1408 <a name="l1388"><span class="ln">1388 </span></a>            date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
1409 <a name="l1389"><span class="ln">1389 </span></a> 
1410 <a name="l1390"><span class="ln">1390 </span></a>            date_str.parseString(&quot;1999/12/31&quot;)  # -&gt; ['1999', '12', '31'] 
1411 <a name="l1391"><span class="ln">1391 </span></a>        &quot;&quot;&quot;</span>
1412 <a name="l1392"><span class="ln">1392 </span></a>        <span class="s1">ParserElement._literalStringClass = cls</span>
1413 <a name="l1393"><span class="ln">1393 </span></a>
1414 <a name="l1394"><span class="ln">1394 </span></a>    <span class="s1">@classmethod</span>
1415 <a name="l1395"><span class="ln">1395 </span></a>    <span class="s3">def </span><span class="s1">_trim_traceback(cls</span><span class="s3">, </span><span class="s1">tb):</span>
1416 <a name="l1396"><span class="ln">1396 </span></a>        <span class="s3">while </span><span class="s1">tb.tb_next:</span>
1417 <a name="l1397"><span class="ln">1397 </span></a>            <span class="s1">tb = tb.tb_next</span>
1418 <a name="l1398"><span class="ln">1398 </span></a>        <span class="s3">return </span><span class="s1">tb</span>
1419 <a name="l1399"><span class="ln">1399 </span></a>
1420 <a name="l1400"><span class="ln">1400 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">):</span>
1421 <a name="l1401"><span class="ln">1401 </span></a>        <span class="s1">self.parseAction = list()</span>
1422 <a name="l1402"><span class="ln">1402 </span></a>        <span class="s1">self.failAction = </span><span class="s3">None</span>
1423 <a name="l1403"><span class="ln">1403 </span></a>        <span class="s0"># ~ self.name = &quot;&lt;unknown&gt;&quot;  # don't define self.name, let subclasses try/except upcall</span>
1424 <a name="l1404"><span class="ln">1404 </span></a>        <span class="s1">self.strRepr = </span><span class="s3">None</span>
1425 <a name="l1405"><span class="ln">1405 </span></a>        <span class="s1">self.resultsName = </span><span class="s3">None</span>
1426 <a name="l1406"><span class="ln">1406 </span></a>        <span class="s1">self.saveAsList = savelist</span>
1427 <a name="l1407"><span class="ln">1407 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">True</span>
1428 <a name="l1408"><span class="ln">1408 </span></a>        <span class="s1">self.whiteChars = set(ParserElement.DEFAULT_WHITE_CHARS)</span>
1429 <a name="l1409"><span class="ln">1409 </span></a>        <span class="s1">self.copyDefaultWhiteChars = </span><span class="s3">True</span>
1430 <a name="l1410"><span class="ln">1410 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">False </span><span class="s0"># used when checking for left-recursion</span>
1431 <a name="l1411"><span class="ln">1411 </span></a>        <span class="s1">self.keepTabs = </span><span class="s3">False</span>
1432 <a name="l1412"><span class="ln">1412 </span></a>        <span class="s1">self.ignoreExprs = list()</span>
1433 <a name="l1413"><span class="ln">1413 </span></a>        <span class="s1">self.debug = </span><span class="s3">False</span>
1434 <a name="l1414"><span class="ln">1414 </span></a>        <span class="s1">self.streamlined = </span><span class="s3">False</span>
1435 <a name="l1415"><span class="ln">1415 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">True </span><span class="s0"># used to optimize exception handling for subclasses that don't advance parse index</span>
1436 <a name="l1416"><span class="ln">1416 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;&quot;</span>
1437 <a name="l1417"><span class="ln">1417 </span></a>        <span class="s1">self.modalResults = </span><span class="s3">True </span><span class="s0"># used to mark results names as modal (report only last) or cumulative (list all)</span>
1438 <a name="l1418"><span class="ln">1418 </span></a>        <span class="s1">self.debugActions = (</span><span class="s3">None, None, None</span><span class="s1">)  </span><span class="s0"># custom debug actions</span>
1439 <a name="l1419"><span class="ln">1419 </span></a>        <span class="s1">self.re = </span><span class="s3">None</span>
1440 <a name="l1420"><span class="ln">1420 </span></a>        <span class="s1">self.callPreparse = </span><span class="s3">True </span><span class="s0"># used to avoid redundant calls to preParse</span>
1441 <a name="l1421"><span class="ln">1421 </span></a>        <span class="s1">self.callDuringTry = </span><span class="s3">False</span>
1442 <a name="l1422"><span class="ln">1422 </span></a>
1443 <a name="l1423"><span class="ln">1423 </span></a>    <span class="s3">def </span><span class="s1">copy(self):</span>
1444 <a name="l1424"><span class="ln">1424 </span></a>        <span class="s5">&quot;&quot;&quot; 
1445 <a name="l1425"><span class="ln">1425 </span></a>        Make a copy of this :class:`ParserElement`.  Useful for defining 
1446 <a name="l1426"><span class="ln">1426 </span></a>        different parse actions for the same parsing pattern, using copies of 
1447 <a name="l1427"><span class="ln">1427 </span></a>        the original parse element. 
1448 <a name="l1428"><span class="ln">1428 </span></a> 
1449 <a name="l1429"><span class="ln">1429 </span></a>        Example:: 
1450 <a name="l1430"><span class="ln">1430 </span></a> 
1451 <a name="l1431"><span class="ln">1431 </span></a>            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
1452 <a name="l1432"><span class="ln">1432 </span></a>            integerK = integer.copy().addParseAction(lambda toks: toks[0] * 1024) + Suppress(&quot;K&quot;) 
1453 <a name="l1433"><span class="ln">1433 </span></a>            integerM = integer.copy().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress(&quot;M&quot;) 
1454 <a name="l1434"><span class="ln">1434 </span></a> 
1455 <a name="l1435"><span class="ln">1435 </span></a>            print(OneOrMore(integerK | integerM | integer).parseString(&quot;5K 100 640K 256M&quot;)) 
1456 <a name="l1436"><span class="ln">1436 </span></a> 
1457 <a name="l1437"><span class="ln">1437 </span></a>        prints:: 
1458 <a name="l1438"><span class="ln">1438 </span></a> 
1459 <a name="l1439"><span class="ln">1439 </span></a>            [5120, 100, 655360, 268435456] 
1460 <a name="l1440"><span class="ln">1440 </span></a> 
1461 <a name="l1441"><span class="ln">1441 </span></a>        Equivalent form of ``expr.copy()`` is just ``expr()``:: 
1462 <a name="l1442"><span class="ln">1442 </span></a> 
1463 <a name="l1443"><span class="ln">1443 </span></a>            integerM = integer().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress(&quot;M&quot;) 
1464 <a name="l1444"><span class="ln">1444 </span></a>        &quot;&quot;&quot;</span>
1465 <a name="l1445"><span class="ln">1445 </span></a>        <span class="s1">cpy = copy.copy(self)</span>
1466 <a name="l1446"><span class="ln">1446 </span></a>        <span class="s1">cpy.parseAction = self.parseAction[:]</span>
1467 <a name="l1447"><span class="ln">1447 </span></a>        <span class="s1">cpy.ignoreExprs = self.ignoreExprs[:]</span>
1468 <a name="l1448"><span class="ln">1448 </span></a>        <span class="s3">if </span><span class="s1">self.copyDefaultWhiteChars:</span>
1469 <a name="l1449"><span class="ln">1449 </span></a>            <span class="s1">cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS</span>
1470 <a name="l1450"><span class="ln">1450 </span></a>        <span class="s3">return </span><span class="s1">cpy</span>
1471 <a name="l1451"><span class="ln">1451 </span></a>
1472 <a name="l1452"><span class="ln">1452 </span></a>    <span class="s3">def </span><span class="s1">setName(self</span><span class="s3">, </span><span class="s1">name):</span>
1473 <a name="l1453"><span class="ln">1453 </span></a>        <span class="s5">&quot;&quot;&quot; 
1474 <a name="l1454"><span class="ln">1454 </span></a>        Define name for this expression, makes debugging and exception messages clearer. 
1475 <a name="l1455"><span class="ln">1455 </span></a> 
1476 <a name="l1456"><span class="ln">1456 </span></a>        Example:: 
1477 <a name="l1457"><span class="ln">1457 </span></a> 
1478 <a name="l1458"><span class="ln">1458 </span></a>            Word(nums).parseString(&quot;ABC&quot;)  # -&gt; Exception: Expected W:(0123...) (at char 0), (line:1, col:1) 
1479 <a name="l1459"><span class="ln">1459 </span></a>            Word(nums).setName(&quot;integer&quot;).parseString(&quot;ABC&quot;)  # -&gt; Exception: Expected integer (at char 0), (line:1, col:1) 
1480 <a name="l1460"><span class="ln">1460 </span></a>        &quot;&quot;&quot;</span>
1481 <a name="l1461"><span class="ln">1461 </span></a>        <span class="s1">self.name = name</span>
1482 <a name="l1462"><span class="ln">1462 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
1483 <a name="l1463"><span class="ln">1463 </span></a>        <span class="s3">if </span><span class="s1">__diag__.enable_debug_on_named_expressions:</span>
1484 <a name="l1464"><span class="ln">1464 </span></a>            <span class="s1">self.setDebug()</span>
1485 <a name="l1465"><span class="ln">1465 </span></a>        <span class="s3">return </span><span class="s1">self</span>
1486 <a name="l1466"><span class="ln">1466 </span></a>
1487 <a name="l1467"><span class="ln">1467 </span></a>    <span class="s3">def </span><span class="s1">setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
1488 <a name="l1468"><span class="ln">1468 </span></a>        <span class="s5">&quot;&quot;&quot; 
1489 <a name="l1469"><span class="ln">1469 </span></a>        Define name for referencing matching tokens as a nested attribute 
1490 <a name="l1470"><span class="ln">1470 </span></a>        of the returned parse results. 
1491 <a name="l1471"><span class="ln">1471 </span></a>        NOTE: this returns a *copy* of the original :class:`ParserElement` object; 
1492 <a name="l1472"><span class="ln">1472 </span></a>        this is so that the client can define a basic element, such as an 
1493 <a name="l1473"><span class="ln">1473 </span></a>        integer, and reference it in multiple places with different names. 
1494 <a name="l1474"><span class="ln">1474 </span></a> 
1495 <a name="l1475"><span class="ln">1475 </span></a>        You can also set results names using the abbreviated syntax, 
1496 <a name="l1476"><span class="ln">1476 </span></a>        ``expr(&quot;name&quot;)`` in place of ``expr.setResultsName(&quot;name&quot;)`` 
1497 <a name="l1477"><span class="ln">1477 </span></a>        - see :class:`__call__`. 
1498 <a name="l1478"><span class="ln">1478 </span></a> 
1499 <a name="l1479"><span class="ln">1479 </span></a>        Example:: 
1500 <a name="l1480"><span class="ln">1480 </span></a> 
1501 <a name="l1481"><span class="ln">1481 </span></a>            date_str = (integer.setResultsName(&quot;year&quot;) + '/' 
1502 <a name="l1482"><span class="ln">1482 </span></a>                        + integer.setResultsName(&quot;month&quot;) + '/' 
1503 <a name="l1483"><span class="ln">1483 </span></a>                        + integer.setResultsName(&quot;day&quot;)) 
1504 <a name="l1484"><span class="ln">1484 </span></a> 
1505 <a name="l1485"><span class="ln">1485 </span></a>            # equivalent form: 
1506 <a name="l1486"><span class="ln">1486 </span></a>            date_str = integer(&quot;year&quot;) + '/' + integer(&quot;month&quot;) + '/' + integer(&quot;day&quot;) 
1507 <a name="l1487"><span class="ln">1487 </span></a>        &quot;&quot;&quot;</span>
1508 <a name="l1488"><span class="ln">1488 </span></a>        <span class="s3">return </span><span class="s1">self._setResultsName(name</span><span class="s3">, </span><span class="s1">listAllMatches)</span>
1509 <a name="l1489"><span class="ln">1489 </span></a>
1510 <a name="l1490"><span class="ln">1490 </span></a>    <span class="s3">def </span><span class="s1">_setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
1511 <a name="l1491"><span class="ln">1491 </span></a>        <span class="s1">newself = self.copy()</span>
1512 <a name="l1492"><span class="ln">1492 </span></a>        <span class="s3">if </span><span class="s1">name.endswith(</span><span class="s2">&quot;*&quot;</span><span class="s1">):</span>
1513 <a name="l1493"><span class="ln">1493 </span></a>            <span class="s1">name = name[:-</span><span class="s4">1</span><span class="s1">]</span>
1514 <a name="l1494"><span class="ln">1494 </span></a>            <span class="s1">listAllMatches = </span><span class="s3">True</span>
1515 <a name="l1495"><span class="ln">1495 </span></a>        <span class="s1">newself.resultsName = name</span>
1516 <a name="l1496"><span class="ln">1496 </span></a>        <span class="s1">newself.modalResults = </span><span class="s3">not </span><span class="s1">listAllMatches</span>
1517 <a name="l1497"><span class="ln">1497 </span></a>        <span class="s3">return </span><span class="s1">newself</span>
1518 <a name="l1498"><span class="ln">1498 </span></a>
1519 <a name="l1499"><span class="ln">1499 </span></a>    <span class="s3">def </span><span class="s1">setBreak(self</span><span class="s3">, </span><span class="s1">breakFlag=</span><span class="s3">True</span><span class="s1">):</span>
1520 <a name="l1500"><span class="ln">1500 </span></a>        <span class="s5">&quot;&quot;&quot;Method to invoke the Python pdb debugger when this element is 
1521 <a name="l1501"><span class="ln">1501 </span></a>           about to be parsed. Set ``breakFlag`` to True to enable, False to 
1522 <a name="l1502"><span class="ln">1502 </span></a>           disable. 
1523 <a name="l1503"><span class="ln">1503 </span></a>        &quot;&quot;&quot;</span>
1524 <a name="l1504"><span class="ln">1504 </span></a>        <span class="s3">if </span><span class="s1">breakFlag:</span>
1525 <a name="l1505"><span class="ln">1505 </span></a>            <span class="s1">_parseMethod = self._parse</span>
1526 <a name="l1506"><span class="ln">1506 </span></a>            <span class="s3">def </span><span class="s1">breaker(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True, </span><span class="s1">callPreParse=</span><span class="s3">True</span><span class="s1">):</span>
1527 <a name="l1507"><span class="ln">1507 </span></a>                <span class="s3">import </span><span class="s1">pdb</span>
1528 <a name="l1508"><span class="ln">1508 </span></a>                <span class="s0"># this call to pdb.set_trace() is intentional, not a checkin error</span>
1529 <a name="l1509"><span class="ln">1509 </span></a>                <span class="s1">pdb.set_trace()</span>
1530 <a name="l1510"><span class="ln">1510 </span></a>                <span class="s3">return </span><span class="s1">_parseMethod(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse)</span>
1531 <a name="l1511"><span class="ln">1511 </span></a>            <span class="s1">breaker._originalParseMethod = _parseMethod</span>
1532 <a name="l1512"><span class="ln">1512 </span></a>            <span class="s1">self._parse = breaker</span>
1533 <a name="l1513"><span class="ln">1513 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1534 <a name="l1514"><span class="ln">1514 </span></a>            <span class="s3">if </span><span class="s1">hasattr(self._parse</span><span class="s3">, </span><span class="s2">&quot;_originalParseMethod&quot;</span><span class="s1">):</span>
1535 <a name="l1515"><span class="ln">1515 </span></a>                <span class="s1">self._parse = self._parse._originalParseMethod</span>
1536 <a name="l1516"><span class="ln">1516 </span></a>        <span class="s3">return </span><span class="s1">self</span>
1537 <a name="l1517"><span class="ln">1517 </span></a>
1538 <a name="l1518"><span class="ln">1518 </span></a>    <span class="s3">def </span><span class="s1">setParseAction(self</span><span class="s3">, </span><span class="s1">*fns</span><span class="s3">, </span><span class="s1">**kwargs):</span>
1539 <a name="l1519"><span class="ln">1519 </span></a>        <span class="s5">&quot;&quot;&quot; 
1540 <a name="l1520"><span class="ln">1520 </span></a>        Define one or more actions to perform when successfully matching parse element definition. 
1541 <a name="l1521"><span class="ln">1521 </span></a>        Parse action fn is a callable method with 0-3 arguments, called as ``fn(s, loc, toks)`` , 
1542 <a name="l1522"><span class="ln">1522 </span></a>        ``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where: 
1543 <a name="l1523"><span class="ln">1523 </span></a> 
1544 <a name="l1524"><span class="ln">1524 </span></a>        - s   = the original string being parsed (see note below) 
1545 <a name="l1525"><span class="ln">1525 </span></a>        - loc = the location of the matching substring 
1546 <a name="l1526"><span class="ln">1526 </span></a>        - toks = a list of the matched tokens, packaged as a :class:`ParseResults` object 
1547 <a name="l1527"><span class="ln">1527 </span></a> 
1548 <a name="l1528"><span class="ln">1528 </span></a>        If the functions in fns modify the tokens, they can return them as the return 
1549 <a name="l1529"><span class="ln">1529 </span></a>        value from fn, and the modified list of tokens will replace the original. 
1550 <a name="l1530"><span class="ln">1530 </span></a>        Otherwise, fn does not need to return any value. 
1551 <a name="l1531"><span class="ln">1531 </span></a> 
1552 <a name="l1532"><span class="ln">1532 </span></a>        If None is passed as the parse action, all previously added parse actions for this 
1553 <a name="l1533"><span class="ln">1533 </span></a>        expression are cleared. 
1554 <a name="l1534"><span class="ln">1534 </span></a> 
1555 <a name="l1535"><span class="ln">1535 </span></a>        Optional keyword arguments: 
1556 <a name="l1536"><span class="ln">1536 </span></a>        - callDuringTry = (default= ``False``) indicate if parse action should be run during lookaheads and alternate testing 
1557 <a name="l1537"><span class="ln">1537 </span></a> 
1558 <a name="l1538"><span class="ln">1538 </span></a>        Note: the default parsing behavior is to expand tabs in the input string 
1559 <a name="l1539"><span class="ln">1539 </span></a>        before starting the parsing process.  See :class:`parseString for more 
1560 <a name="l1540"><span class="ln">1540 </span></a>        information on parsing strings containing ``&lt;TAB&gt;`` s, and suggested 
1561 <a name="l1541"><span class="ln">1541 </span></a>        methods to maintain a consistent view of the parsed string, the parse 
1562 <a name="l1542"><span class="ln">1542 </span></a>        location, and line and column positions within the parsed string. 
1563 <a name="l1543"><span class="ln">1543 </span></a> 
1564 <a name="l1544"><span class="ln">1544 </span></a>        Example:: 
1565 <a name="l1545"><span class="ln">1545 </span></a> 
1566 <a name="l1546"><span class="ln">1546 </span></a>            integer = Word(nums) 
1567 <a name="l1547"><span class="ln">1547 </span></a>            date_str = integer + '/' + integer + '/' + integer 
1568 <a name="l1548"><span class="ln">1548 </span></a> 
1569 <a name="l1549"><span class="ln">1549 </span></a>            date_str.parseString(&quot;1999/12/31&quot;)  # -&gt; ['1999', '/', '12', '/', '31'] 
1570 <a name="l1550"><span class="ln">1550 </span></a> 
1571 <a name="l1551"><span class="ln">1551 </span></a>            # use parse action to convert to ints at parse time 
1572 <a name="l1552"><span class="ln">1552 </span></a>            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
1573 <a name="l1553"><span class="ln">1553 </span></a>            date_str = integer + '/' + integer + '/' + integer 
1574 <a name="l1554"><span class="ln">1554 </span></a> 
1575 <a name="l1555"><span class="ln">1555 </span></a>            # note that integer fields are now ints, not strings 
1576 <a name="l1556"><span class="ln">1556 </span></a>            date_str.parseString(&quot;1999/12/31&quot;)  # -&gt; [1999, '/', 12, '/', 31] 
1577 <a name="l1557"><span class="ln">1557 </span></a>        &quot;&quot;&quot;</span>
1578 <a name="l1558"><span class="ln">1558 </span></a>        <span class="s3">if </span><span class="s1">list(fns) == [</span><span class="s3">None,</span><span class="s1">]:</span>
1579 <a name="l1559"><span class="ln">1559 </span></a>            <span class="s1">self.parseAction = []</span>
1580 <a name="l1560"><span class="ln">1560 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1581 <a name="l1561"><span class="ln">1561 </span></a>            <span class="s3">if not </span><span class="s1">all(callable(fn) </span><span class="s3">for </span><span class="s1">fn </span><span class="s3">in </span><span class="s1">fns):</span>
1582 <a name="l1562"><span class="ln">1562 </span></a>                <span class="s3">raise </span><span class="s1">TypeError(</span><span class="s2">&quot;parse actions must be callable&quot;</span><span class="s1">)</span>
1583 <a name="l1563"><span class="ln">1563 </span></a>            <span class="s1">self.parseAction = list(map(_trim_arity</span><span class="s3">, </span><span class="s1">list(fns)))</span>
1584 <a name="l1564"><span class="ln">1564 </span></a>            <span class="s1">self.callDuringTry = kwargs.get(</span><span class="s2">&quot;callDuringTry&quot;</span><span class="s3">, False</span><span class="s1">)</span>
1585 <a name="l1565"><span class="ln">1565 </span></a>        <span class="s3">return </span><span class="s1">self</span>
1586 <a name="l1566"><span class="ln">1566 </span></a>
1587 <a name="l1567"><span class="ln">1567 </span></a>    <span class="s3">def </span><span class="s1">addParseAction(self</span><span class="s3">, </span><span class="s1">*fns</span><span class="s3">, </span><span class="s1">**kwargs):</span>
1588 <a name="l1568"><span class="ln">1568 </span></a>        <span class="s5">&quot;&quot;&quot; 
1589 <a name="l1569"><span class="ln">1569 </span></a>        Add one or more parse actions to expression's list of parse actions. See :class:`setParseAction`. 
1590 <a name="l1570"><span class="ln">1570 </span></a> 
1591 <a name="l1571"><span class="ln">1571 </span></a>        See examples in :class:`copy`. 
1592 <a name="l1572"><span class="ln">1572 </span></a>        &quot;&quot;&quot;</span>
1593 <a name="l1573"><span class="ln">1573 </span></a>        <span class="s1">self.parseAction += list(map(_trim_arity</span><span class="s3">, </span><span class="s1">list(fns)))</span>
1594 <a name="l1574"><span class="ln">1574 </span></a>        <span class="s1">self.callDuringTry = self.callDuringTry </span><span class="s3">or </span><span class="s1">kwargs.get(</span><span class="s2">&quot;callDuringTry&quot;</span><span class="s3">, False</span><span class="s1">)</span>
1595 <a name="l1575"><span class="ln">1575 </span></a>        <span class="s3">return </span><span class="s1">self</span>
1596 <a name="l1576"><span class="ln">1576 </span></a>
1597 <a name="l1577"><span class="ln">1577 </span></a>    <span class="s3">def </span><span class="s1">addCondition(self</span><span class="s3">, </span><span class="s1">*fns</span><span class="s3">, </span><span class="s1">**kwargs):</span>
1598 <a name="l1578"><span class="ln">1578 </span></a>        <span class="s5">&quot;&quot;&quot;Add a boolean predicate function to expression's list of parse actions. See 
1599 <a name="l1579"><span class="ln">1579 </span></a>        :class:`setParseAction` for function call signatures. Unlike ``setParseAction``, 
1600 <a name="l1580"><span class="ln">1580 </span></a>        functions passed to ``addCondition`` need to return boolean success/fail of the condition. 
1601 <a name="l1581"><span class="ln">1581 </span></a> 
1602 <a name="l1582"><span class="ln">1582 </span></a>        Optional keyword arguments: 
1603 <a name="l1583"><span class="ln">1583 </span></a>        - message = define a custom message to be used in the raised exception 
1604 <a name="l1584"><span class="ln">1584 </span></a>        - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException 
1605 <a name="l1585"><span class="ln">1585 </span></a> 
1606 <a name="l1586"><span class="ln">1586 </span></a>        Example:: 
1607 <a name="l1587"><span class="ln">1587 </span></a> 
1608 <a name="l1588"><span class="ln">1588 </span></a>            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
1609 <a name="l1589"><span class="ln">1589 </span></a>            year_int = integer.copy() 
1610 <a name="l1590"><span class="ln">1590 </span></a>            year_int.addCondition(lambda toks: toks[0] &gt;= 2000, message=&quot;Only support years 2000 and later&quot;) 
1611 <a name="l1591"><span class="ln">1591 </span></a>            date_str = year_int + '/' + integer + '/' + integer 
1612 <a name="l1592"><span class="ln">1592 </span></a> 
1613 <a name="l1593"><span class="ln">1593 </span></a>            result = date_str.parseString(&quot;1999/12/31&quot;)  # -&gt; Exception: Only support years 2000 and later (at char 0), (line:1, col:1) 
1614 <a name="l1594"><span class="ln">1594 </span></a>        &quot;&quot;&quot;</span>
1615 <a name="l1595"><span class="ln">1595 </span></a>        <span class="s3">for </span><span class="s1">fn </span><span class="s3">in </span><span class="s1">fns:</span>
1616 <a name="l1596"><span class="ln">1596 </span></a>            <span class="s1">self.parseAction.append(conditionAsParseAction(fn</span><span class="s3">, </span><span class="s1">message=kwargs.get(</span><span class="s2">'message'</span><span class="s1">)</span><span class="s3">,</span>
1617 <a name="l1597"><span class="ln">1597 </span></a>                                                           <span class="s1">fatal=kwargs.get(</span><span class="s2">'fatal'</span><span class="s3">, False</span><span class="s1">)))</span>
1618 <a name="l1598"><span class="ln">1598 </span></a>
1619 <a name="l1599"><span class="ln">1599 </span></a>        <span class="s1">self.callDuringTry = self.callDuringTry </span><span class="s3">or </span><span class="s1">kwargs.get(</span><span class="s2">&quot;callDuringTry&quot;</span><span class="s3">, False</span><span class="s1">)</span>
1620 <a name="l1600"><span class="ln">1600 </span></a>        <span class="s3">return </span><span class="s1">self</span>
1621 <a name="l1601"><span class="ln">1601 </span></a>
1622 <a name="l1602"><span class="ln">1602 </span></a>    <span class="s3">def </span><span class="s1">setFailAction(self</span><span class="s3">, </span><span class="s1">fn):</span>
1623 <a name="l1603"><span class="ln">1603 </span></a>        <span class="s5">&quot;&quot;&quot;Define action to perform if parsing fails at this expression. 
1624 <a name="l1604"><span class="ln">1604 </span></a>           Fail acton fn is a callable function that takes the arguments 
1625 <a name="l1605"><span class="ln">1605 </span></a>           ``fn(s, loc, expr, err)`` where: 
1626 <a name="l1606"><span class="ln">1606 </span></a>           - s = string being parsed 
1627 <a name="l1607"><span class="ln">1607 </span></a>           - loc = location where expression match was attempted and failed 
1628 <a name="l1608"><span class="ln">1608 </span></a>           - expr = the parse expression that failed 
1629 <a name="l1609"><span class="ln">1609 </span></a>           - err = the exception thrown 
1630 <a name="l1610"><span class="ln">1610 </span></a>           The function returns no value.  It may throw :class:`ParseFatalException` 
1631 <a name="l1611"><span class="ln">1611 </span></a>           if it is desired to stop parsing immediately.&quot;&quot;&quot;</span>
1632 <a name="l1612"><span class="ln">1612 </span></a>        <span class="s1">self.failAction = fn</span>
1633 <a name="l1613"><span class="ln">1613 </span></a>        <span class="s3">return </span><span class="s1">self</span>
1634 <a name="l1614"><span class="ln">1614 </span></a>
1635 <a name="l1615"><span class="ln">1615 </span></a>    <span class="s3">def </span><span class="s1">_skipIgnorables(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc):</span>
1636 <a name="l1616"><span class="ln">1616 </span></a>        <span class="s1">exprsFound = </span><span class="s3">True</span>
1637 <a name="l1617"><span class="ln">1617 </span></a>        <span class="s3">while </span><span class="s1">exprsFound:</span>
1638 <a name="l1618"><span class="ln">1618 </span></a>            <span class="s1">exprsFound = </span><span class="s3">False</span>
1639 <a name="l1619"><span class="ln">1619 </span></a>            <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.ignoreExprs:</span>
1640 <a name="l1620"><span class="ln">1620 </span></a>                <span class="s3">try</span><span class="s1">:</span>
1641 <a name="l1621"><span class="ln">1621 </span></a>                    <span class="s3">while </span><span class="s4">1</span><span class="s1">:</span>
1642 <a name="l1622"><span class="ln">1622 </span></a>                        <span class="s1">loc</span><span class="s3">, </span><span class="s1">dummy = e._parse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1643 <a name="l1623"><span class="ln">1623 </span></a>                        <span class="s1">exprsFound = </span><span class="s3">True</span>
1644 <a name="l1624"><span class="ln">1624 </span></a>                <span class="s3">except </span><span class="s1">ParseException:</span>
1645 <a name="l1625"><span class="ln">1625 </span></a>                    <span class="s3">pass</span>
1646 <a name="l1626"><span class="ln">1626 </span></a>        <span class="s3">return </span><span class="s1">loc</span>
1647 <a name="l1627"><span class="ln">1627 </span></a>
1648 <a name="l1628"><span class="ln">1628 </span></a>    <span class="s3">def </span><span class="s1">preParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc):</span>
1649 <a name="l1629"><span class="ln">1629 </span></a>        <span class="s3">if </span><span class="s1">self.ignoreExprs:</span>
1650 <a name="l1630"><span class="ln">1630 </span></a>            <span class="s1">loc = self._skipIgnorables(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1651 <a name="l1631"><span class="ln">1631 </span></a>
1652 <a name="l1632"><span class="ln">1632 </span></a>        <span class="s3">if </span><span class="s1">self.skipWhitespace:</span>
1653 <a name="l1633"><span class="ln">1633 </span></a>            <span class="s1">wt = self.whiteChars</span>
1654 <a name="l1634"><span class="ln">1634 </span></a>            <span class="s1">instrlen = len(instring)</span>
1655 <a name="l1635"><span class="ln">1635 </span></a>            <span class="s3">while </span><span class="s1">loc &lt; instrlen </span><span class="s3">and </span><span class="s1">instring[loc] </span><span class="s3">in </span><span class="s1">wt:</span>
1656 <a name="l1636"><span class="ln">1636 </span></a>                <span class="s1">loc += </span><span class="s4">1</span>
1657 <a name="l1637"><span class="ln">1637 </span></a>
1658 <a name="l1638"><span class="ln">1638 </span></a>        <span class="s3">return </span><span class="s1">loc</span>
1659 <a name="l1639"><span class="ln">1639 </span></a>
1660 <a name="l1640"><span class="ln">1640 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
1661 <a name="l1641"><span class="ln">1641 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
1662 <a name="l1642"><span class="ln">1642 </span></a>
1663 <a name="l1643"><span class="ln">1643 </span></a>    <span class="s3">def </span><span class="s1">postParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokenlist):</span>
1664 <a name="l1644"><span class="ln">1644 </span></a>        <span class="s3">return </span><span class="s1">tokenlist</span>
1665 <a name="l1645"><span class="ln">1645 </span></a>
1666 <a name="l1646"><span class="ln">1646 </span></a>    <span class="s0"># ~ @profile</span>
1667 <a name="l1647"><span class="ln">1647 </span></a>    <span class="s3">def </span><span class="s1">_parseNoCache(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True, </span><span class="s1">callPreParse=</span><span class="s3">True</span><span class="s1">):</span>
1668 <a name="l1648"><span class="ln">1648 </span></a>        <span class="s1">TRY</span><span class="s3">, </span><span class="s1">MATCH</span><span class="s3">, </span><span class="s1">FAIL = </span><span class="s4">0</span><span class="s3">, </span><span class="s4">1</span><span class="s3">, </span><span class="s4">2</span>
1669 <a name="l1649"><span class="ln">1649 </span></a>        <span class="s1">debugging = (self.debug)  </span><span class="s0"># and doActions)</span>
1670 <a name="l1650"><span class="ln">1650 </span></a>
1671 <a name="l1651"><span class="ln">1651 </span></a>        <span class="s3">if </span><span class="s1">debugging </span><span class="s3">or </span><span class="s1">self.failAction:</span>
1672 <a name="l1652"><span class="ln">1652 </span></a>            <span class="s0"># ~ print (&quot;Match&quot;, self, &quot;at loc&quot;, loc, &quot;(%d, %d)&quot; % (lineno(loc, instring), col(loc, instring)))</span>
1673 <a name="l1653"><span class="ln">1653 </span></a>            <span class="s3">if </span><span class="s1">self.debugActions[TRY]:</span>
1674 <a name="l1654"><span class="ln">1654 </span></a>                <span class="s1">self.debugActions[TRY](instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self)</span>
1675 <a name="l1655"><span class="ln">1655 </span></a>            <span class="s3">try</span><span class="s1">:</span>
1676 <a name="l1656"><span class="ln">1656 </span></a>                <span class="s3">if </span><span class="s1">callPreParse </span><span class="s3">and </span><span class="s1">self.callPreparse:</span>
1677 <a name="l1657"><span class="ln">1657 </span></a>                    <span class="s1">preloc = self.preParse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1678 <a name="l1658"><span class="ln">1658 </span></a>                <span class="s3">else</span><span class="s1">:</span>
1679 <a name="l1659"><span class="ln">1659 </span></a>                    <span class="s1">preloc = loc</span>
1680 <a name="l1660"><span class="ln">1660 </span></a>                <span class="s1">tokensStart = preloc</span>
1681 <a name="l1661"><span class="ln">1661 </span></a>                <span class="s3">if </span><span class="s1">self.mayIndexError </span><span class="s3">or </span><span class="s1">preloc &gt;= len(instring):</span>
1682 <a name="l1662"><span class="ln">1662 </span></a>                    <span class="s3">try</span><span class="s1">:</span>
1683 <a name="l1663"><span class="ln">1663 </span></a>                        <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self.parseImpl(instring</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">doActions)</span>
1684 <a name="l1664"><span class="ln">1664 </span></a>                    <span class="s3">except </span><span class="s1">IndexError:</span>
1685 <a name="l1665"><span class="ln">1665 </span></a>                        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">len(instring)</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
1686 <a name="l1666"><span class="ln">1666 </span></a>                <span class="s3">else</span><span class="s1">:</span>
1687 <a name="l1667"><span class="ln">1667 </span></a>                    <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self.parseImpl(instring</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">doActions)</span>
1688 <a name="l1668"><span class="ln">1668 </span></a>            <span class="s3">except </span><span class="s1">Exception </span><span class="s3">as </span><span class="s1">err:</span>
1689 <a name="l1669"><span class="ln">1669 </span></a>                <span class="s0"># ~ print (&quot;Exception raised:&quot;, err)</span>
1690 <a name="l1670"><span class="ln">1670 </span></a>                <span class="s3">if </span><span class="s1">self.debugActions[FAIL]:</span>
1691 <a name="l1671"><span class="ln">1671 </span></a>                    <span class="s1">self.debugActions[FAIL](instring</span><span class="s3">, </span><span class="s1">tokensStart</span><span class="s3">, </span><span class="s1">self</span><span class="s3">, </span><span class="s1">err)</span>
1692 <a name="l1672"><span class="ln">1672 </span></a>                <span class="s3">if </span><span class="s1">self.failAction:</span>
1693 <a name="l1673"><span class="ln">1673 </span></a>                    <span class="s1">self.failAction(instring</span><span class="s3">, </span><span class="s1">tokensStart</span><span class="s3">, </span><span class="s1">self</span><span class="s3">, </span><span class="s1">err)</span>
1694 <a name="l1674"><span class="ln">1674 </span></a>                <span class="s3">raise</span>
1695 <a name="l1675"><span class="ln">1675 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1696 <a name="l1676"><span class="ln">1676 </span></a>            <span class="s3">if </span><span class="s1">callPreParse </span><span class="s3">and </span><span class="s1">self.callPreparse:</span>
1697 <a name="l1677"><span class="ln">1677 </span></a>                <span class="s1">preloc = self.preParse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1698 <a name="l1678"><span class="ln">1678 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1699 <a name="l1679"><span class="ln">1679 </span></a>                <span class="s1">preloc = loc</span>
1700 <a name="l1680"><span class="ln">1680 </span></a>            <span class="s1">tokensStart = preloc</span>
1701 <a name="l1681"><span class="ln">1681 </span></a>            <span class="s3">if </span><span class="s1">self.mayIndexError </span><span class="s3">or </span><span class="s1">preloc &gt;= len(instring):</span>
1702 <a name="l1682"><span class="ln">1682 </span></a>                <span class="s3">try</span><span class="s1">:</span>
1703 <a name="l1683"><span class="ln">1683 </span></a>                    <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self.parseImpl(instring</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">doActions)</span>
1704 <a name="l1684"><span class="ln">1684 </span></a>                <span class="s3">except </span><span class="s1">IndexError:</span>
1705 <a name="l1685"><span class="ln">1685 </span></a>                    <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">len(instring)</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
1706 <a name="l1686"><span class="ln">1686 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1707 <a name="l1687"><span class="ln">1687 </span></a>                <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self.parseImpl(instring</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">doActions)</span>
1708 <a name="l1688"><span class="ln">1688 </span></a>
1709 <a name="l1689"><span class="ln">1689 </span></a>        <span class="s1">tokens = self.postParse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens)</span>
1710 <a name="l1690"><span class="ln">1690 </span></a>
1711 <a name="l1691"><span class="ln">1691 </span></a>        <span class="s1">retTokens = ParseResults(tokens</span><span class="s3">, </span><span class="s1">self.resultsName</span><span class="s3">, </span><span class="s1">asList=self.saveAsList</span><span class="s3">, </span><span class="s1">modal=self.modalResults)</span>
1712 <a name="l1692"><span class="ln">1692 </span></a>        <span class="s3">if </span><span class="s1">self.parseAction </span><span class="s3">and </span><span class="s1">(doActions </span><span class="s3">or </span><span class="s1">self.callDuringTry):</span>
1713 <a name="l1693"><span class="ln">1693 </span></a>            <span class="s3">if </span><span class="s1">debugging:</span>
1714 <a name="l1694"><span class="ln">1694 </span></a>                <span class="s3">try</span><span class="s1">:</span>
1715 <a name="l1695"><span class="ln">1695 </span></a>                    <span class="s3">for </span><span class="s1">fn </span><span class="s3">in </span><span class="s1">self.parseAction:</span>
1716 <a name="l1696"><span class="ln">1696 </span></a>                        <span class="s3">try</span><span class="s1">:</span>
1717 <a name="l1697"><span class="ln">1697 </span></a>                            <span class="s1">tokens = fn(instring</span><span class="s3">, </span><span class="s1">tokensStart</span><span class="s3">, </span><span class="s1">retTokens)</span>
1718 <a name="l1698"><span class="ln">1698 </span></a>                        <span class="s3">except </span><span class="s1">IndexError </span><span class="s3">as </span><span class="s1">parse_action_exc:</span>
1719 <a name="l1699"><span class="ln">1699 </span></a>                            <span class="s1">exc = ParseException(</span><span class="s2">&quot;exception raised in parse action&quot;</span><span class="s1">)</span>
1720 <a name="l1700"><span class="ln">1700 </span></a>                            <span class="s1">exc.__cause__ = parse_action_exc</span>
1721 <a name="l1701"><span class="ln">1701 </span></a>                            <span class="s3">raise </span><span class="s1">exc</span>
1722 <a name="l1702"><span class="ln">1702 </span></a>
1723 <a name="l1703"><span class="ln">1703 </span></a>                        <span class="s3">if </span><span class="s1">tokens </span><span class="s3">is not None and </span><span class="s1">tokens </span><span class="s3">is not </span><span class="s1">retTokens:</span>
1724 <a name="l1704"><span class="ln">1704 </span></a>                            <span class="s1">retTokens = ParseResults(tokens</span><span class="s3">,</span>
1725 <a name="l1705"><span class="ln">1705 </span></a>                                                      <span class="s1">self.resultsName</span><span class="s3">,</span>
1726 <a name="l1706"><span class="ln">1706 </span></a>                                                      <span class="s1">asList=self.saveAsList </span><span class="s3">and </span><span class="s1">isinstance(tokens</span><span class="s3">, </span><span class="s1">(ParseResults</span><span class="s3">, </span><span class="s1">list))</span><span class="s3">,</span>
1727 <a name="l1707"><span class="ln">1707 </span></a>                                                      <span class="s1">modal=self.modalResults)</span>
1728 <a name="l1708"><span class="ln">1708 </span></a>                <span class="s3">except </span><span class="s1">Exception </span><span class="s3">as </span><span class="s1">err:</span>
1729 <a name="l1709"><span class="ln">1709 </span></a>                    <span class="s0"># ~ print &quot;Exception raised in user parse action:&quot;, err</span>
1730 <a name="l1710"><span class="ln">1710 </span></a>                    <span class="s3">if </span><span class="s1">self.debugActions[FAIL]:</span>
1731 <a name="l1711"><span class="ln">1711 </span></a>                        <span class="s1">self.debugActions[FAIL](instring</span><span class="s3">, </span><span class="s1">tokensStart</span><span class="s3">, </span><span class="s1">self</span><span class="s3">, </span><span class="s1">err)</span>
1732 <a name="l1712"><span class="ln">1712 </span></a>                    <span class="s3">raise</span>
1733 <a name="l1713"><span class="ln">1713 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1734 <a name="l1714"><span class="ln">1714 </span></a>                <span class="s3">for </span><span class="s1">fn </span><span class="s3">in </span><span class="s1">self.parseAction:</span>
1735 <a name="l1715"><span class="ln">1715 </span></a>                    <span class="s3">try</span><span class="s1">:</span>
1736 <a name="l1716"><span class="ln">1716 </span></a>                        <span class="s1">tokens = fn(instring</span><span class="s3">, </span><span class="s1">tokensStart</span><span class="s3">, </span><span class="s1">retTokens)</span>
1737 <a name="l1717"><span class="ln">1717 </span></a>                    <span class="s3">except </span><span class="s1">IndexError </span><span class="s3">as </span><span class="s1">parse_action_exc:</span>
1738 <a name="l1718"><span class="ln">1718 </span></a>                        <span class="s1">exc = ParseException(</span><span class="s2">&quot;exception raised in parse action&quot;</span><span class="s1">)</span>
1739 <a name="l1719"><span class="ln">1719 </span></a>                        <span class="s1">exc.__cause__ = parse_action_exc</span>
1740 <a name="l1720"><span class="ln">1720 </span></a>                        <span class="s3">raise </span><span class="s1">exc</span>
1741 <a name="l1721"><span class="ln">1721 </span></a>
1742 <a name="l1722"><span class="ln">1722 </span></a>                    <span class="s3">if </span><span class="s1">tokens </span><span class="s3">is not None and </span><span class="s1">tokens </span><span class="s3">is not </span><span class="s1">retTokens:</span>
1743 <a name="l1723"><span class="ln">1723 </span></a>                        <span class="s1">retTokens = ParseResults(tokens</span><span class="s3">,</span>
1744 <a name="l1724"><span class="ln">1724 </span></a>                                                  <span class="s1">self.resultsName</span><span class="s3">,</span>
1745 <a name="l1725"><span class="ln">1725 </span></a>                                                  <span class="s1">asList=self.saveAsList </span><span class="s3">and </span><span class="s1">isinstance(tokens</span><span class="s3">, </span><span class="s1">(ParseResults</span><span class="s3">, </span><span class="s1">list))</span><span class="s3">,</span>
1746 <a name="l1726"><span class="ln">1726 </span></a>                                                  <span class="s1">modal=self.modalResults)</span>
1747 <a name="l1727"><span class="ln">1727 </span></a>        <span class="s3">if </span><span class="s1">debugging:</span>
1748 <a name="l1728"><span class="ln">1728 </span></a>            <span class="s0"># ~ print (&quot;Matched&quot;, self, &quot;-&gt;&quot;, retTokens.asList())</span>
1749 <a name="l1729"><span class="ln">1729 </span></a>            <span class="s3">if </span><span class="s1">self.debugActions[MATCH]:</span>
1750 <a name="l1730"><span class="ln">1730 </span></a>                <span class="s1">self.debugActions[MATCH](instring</span><span class="s3">, </span><span class="s1">tokensStart</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self</span><span class="s3">, </span><span class="s1">retTokens)</span>
1751 <a name="l1731"><span class="ln">1731 </span></a>
1752 <a name="l1732"><span class="ln">1732 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">retTokens</span>
1753 <a name="l1733"><span class="ln">1733 </span></a>
1754 <a name="l1734"><span class="ln">1734 </span></a>    <span class="s3">def </span><span class="s1">tryParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc):</span>
1755 <a name="l1735"><span class="ln">1735 </span></a>        <span class="s3">try</span><span class="s1">:</span>
1756 <a name="l1736"><span class="ln">1736 </span></a>            <span class="s3">return </span><span class="s1">self._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">False</span><span class="s1">)[</span><span class="s4">0</span><span class="s1">]</span>
1757 <a name="l1737"><span class="ln">1737 </span></a>        <span class="s3">except </span><span class="s1">ParseFatalException:</span>
1758 <a name="l1738"><span class="ln">1738 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
1759 <a name="l1739"><span class="ln">1739 </span></a>
1760 <a name="l1740"><span class="ln">1740 </span></a>    <span class="s3">def </span><span class="s1">canParseNext(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc):</span>
1761 <a name="l1741"><span class="ln">1741 </span></a>        <span class="s3">try</span><span class="s1">:</span>
1762 <a name="l1742"><span class="ln">1742 </span></a>            <span class="s1">self.tryParse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1763 <a name="l1743"><span class="ln">1743 </span></a>        <span class="s3">except </span><span class="s1">(ParseException</span><span class="s3">, </span><span class="s1">IndexError):</span>
1764 <a name="l1744"><span class="ln">1744 </span></a>            <span class="s3">return False</span>
1765 <a name="l1745"><span class="ln">1745 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1766 <a name="l1746"><span class="ln">1746 </span></a>            <span class="s3">return True</span>
1767 <a name="l1747"><span class="ln">1747 </span></a>
1768 <a name="l1748"><span class="ln">1748 </span></a>    <span class="s3">class </span><span class="s1">_UnboundedCache(object):</span>
1769 <a name="l1749"><span class="ln">1749 </span></a>        <span class="s3">def </span><span class="s1">__init__(self):</span>
1770 <a name="l1750"><span class="ln">1750 </span></a>            <span class="s1">cache = {}</span>
1771 <a name="l1751"><span class="ln">1751 </span></a>            <span class="s1">self.not_in_cache = not_in_cache = object()</span>
1772 <a name="l1752"><span class="ln">1752 </span></a>
1773 <a name="l1753"><span class="ln">1753 </span></a>            <span class="s3">def </span><span class="s1">get(self</span><span class="s3">, </span><span class="s1">key):</span>
1774 <a name="l1754"><span class="ln">1754 </span></a>                <span class="s3">return </span><span class="s1">cache.get(key</span><span class="s3">, </span><span class="s1">not_in_cache)</span>
1775 <a name="l1755"><span class="ln">1755 </span></a>
1776 <a name="l1756"><span class="ln">1756 </span></a>            <span class="s3">def </span><span class="s1">set(self</span><span class="s3">, </span><span class="s1">key</span><span class="s3">, </span><span class="s1">value):</span>
1777 <a name="l1757"><span class="ln">1757 </span></a>                <span class="s1">cache[key] = value</span>
1778 <a name="l1758"><span class="ln">1758 </span></a>
1779 <a name="l1759"><span class="ln">1759 </span></a>            <span class="s3">def </span><span class="s1">clear(self):</span>
1780 <a name="l1760"><span class="ln">1760 </span></a>                <span class="s1">cache.clear()</span>
1781 <a name="l1761"><span class="ln">1761 </span></a>
1782 <a name="l1762"><span class="ln">1762 </span></a>            <span class="s3">def </span><span class="s1">cache_len(self):</span>
1783 <a name="l1763"><span class="ln">1763 </span></a>                <span class="s3">return </span><span class="s1">len(cache)</span>
1784 <a name="l1764"><span class="ln">1764 </span></a>
1785 <a name="l1765"><span class="ln">1765 </span></a>            <span class="s1">self.get = types.MethodType(get</span><span class="s3">, </span><span class="s1">self)</span>
1786 <a name="l1766"><span class="ln">1766 </span></a>            <span class="s1">self.set = types.MethodType(set</span><span class="s3">, </span><span class="s1">self)</span>
1787 <a name="l1767"><span class="ln">1767 </span></a>            <span class="s1">self.clear = types.MethodType(clear</span><span class="s3">, </span><span class="s1">self)</span>
1788 <a name="l1768"><span class="ln">1768 </span></a>            <span class="s1">self.__len__ = types.MethodType(cache_len</span><span class="s3">, </span><span class="s1">self)</span>
1789 <a name="l1769"><span class="ln">1769 </span></a>
1790 <a name="l1770"><span class="ln">1770 </span></a>    <span class="s3">if </span><span class="s1">_OrderedDict </span><span class="s3">is not None</span><span class="s1">:</span>
1791 <a name="l1771"><span class="ln">1771 </span></a>        <span class="s3">class </span><span class="s1">_FifoCache(object):</span>
1792 <a name="l1772"><span class="ln">1772 </span></a>            <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">size):</span>
1793 <a name="l1773"><span class="ln">1773 </span></a>                <span class="s1">self.not_in_cache = not_in_cache = object()</span>
1794 <a name="l1774"><span class="ln">1774 </span></a>
1795 <a name="l1775"><span class="ln">1775 </span></a>                <span class="s1">cache = _OrderedDict()</span>
1796 <a name="l1776"><span class="ln">1776 </span></a>
1797 <a name="l1777"><span class="ln">1777 </span></a>                <span class="s3">def </span><span class="s1">get(self</span><span class="s3">, </span><span class="s1">key):</span>
1798 <a name="l1778"><span class="ln">1778 </span></a>                    <span class="s3">return </span><span class="s1">cache.get(key</span><span class="s3">, </span><span class="s1">not_in_cache)</span>
1799 <a name="l1779"><span class="ln">1779 </span></a>
1800 <a name="l1780"><span class="ln">1780 </span></a>                <span class="s3">def </span><span class="s1">set(self</span><span class="s3">, </span><span class="s1">key</span><span class="s3">, </span><span class="s1">value):</span>
1801 <a name="l1781"><span class="ln">1781 </span></a>                    <span class="s1">cache[key] = value</span>
1802 <a name="l1782"><span class="ln">1782 </span></a>                    <span class="s3">while </span><span class="s1">len(cache) &gt; size:</span>
1803 <a name="l1783"><span class="ln">1783 </span></a>                        <span class="s3">try</span><span class="s1">:</span>
1804 <a name="l1784"><span class="ln">1784 </span></a>                            <span class="s1">cache.popitem(</span><span class="s3">False</span><span class="s1">)</span>
1805 <a name="l1785"><span class="ln">1785 </span></a>                        <span class="s3">except </span><span class="s1">KeyError:</span>
1806 <a name="l1786"><span class="ln">1786 </span></a>                            <span class="s3">pass</span>
1807 <a name="l1787"><span class="ln">1787 </span></a>
1808 <a name="l1788"><span class="ln">1788 </span></a>                <span class="s3">def </span><span class="s1">clear(self):</span>
1809 <a name="l1789"><span class="ln">1789 </span></a>                    <span class="s1">cache.clear()</span>
1810 <a name="l1790"><span class="ln">1790 </span></a>
1811 <a name="l1791"><span class="ln">1791 </span></a>                <span class="s3">def </span><span class="s1">cache_len(self):</span>
1812 <a name="l1792"><span class="ln">1792 </span></a>                    <span class="s3">return </span><span class="s1">len(cache)</span>
1813 <a name="l1793"><span class="ln">1793 </span></a>
1814 <a name="l1794"><span class="ln">1794 </span></a>                <span class="s1">self.get = types.MethodType(get</span><span class="s3">, </span><span class="s1">self)</span>
1815 <a name="l1795"><span class="ln">1795 </span></a>                <span class="s1">self.set = types.MethodType(set</span><span class="s3">, </span><span class="s1">self)</span>
1816 <a name="l1796"><span class="ln">1796 </span></a>                <span class="s1">self.clear = types.MethodType(clear</span><span class="s3">, </span><span class="s1">self)</span>
1817 <a name="l1797"><span class="ln">1797 </span></a>                <span class="s1">self.__len__ = types.MethodType(cache_len</span><span class="s3">, </span><span class="s1">self)</span>
1818 <a name="l1798"><span class="ln">1798 </span></a>
1819 <a name="l1799"><span class="ln">1799 </span></a>    <span class="s3">else</span><span class="s1">:</span>
1820 <a name="l1800"><span class="ln">1800 </span></a>        <span class="s3">class </span><span class="s1">_FifoCache(object):</span>
1821 <a name="l1801"><span class="ln">1801 </span></a>            <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">size):</span>
1822 <a name="l1802"><span class="ln">1802 </span></a>                <span class="s1">self.not_in_cache = not_in_cache = object()</span>
1823 <a name="l1803"><span class="ln">1803 </span></a>
1824 <a name="l1804"><span class="ln">1804 </span></a>                <span class="s1">cache = {}</span>
1825 <a name="l1805"><span class="ln">1805 </span></a>                <span class="s1">key_fifo = collections.deque([]</span><span class="s3">, </span><span class="s1">size)</span>
1826 <a name="l1806"><span class="ln">1806 </span></a>
1827 <a name="l1807"><span class="ln">1807 </span></a>                <span class="s3">def </span><span class="s1">get(self</span><span class="s3">, </span><span class="s1">key):</span>
1828 <a name="l1808"><span class="ln">1808 </span></a>                    <span class="s3">return </span><span class="s1">cache.get(key</span><span class="s3">, </span><span class="s1">not_in_cache)</span>
1829 <a name="l1809"><span class="ln">1809 </span></a>
1830 <a name="l1810"><span class="ln">1810 </span></a>                <span class="s3">def </span><span class="s1">set(self</span><span class="s3">, </span><span class="s1">key</span><span class="s3">, </span><span class="s1">value):</span>
1831 <a name="l1811"><span class="ln">1811 </span></a>                    <span class="s1">cache[key] = value</span>
1832 <a name="l1812"><span class="ln">1812 </span></a>                    <span class="s3">while </span><span class="s1">len(key_fifo) &gt; size:</span>
1833 <a name="l1813"><span class="ln">1813 </span></a>                        <span class="s1">cache.pop(key_fifo.popleft()</span><span class="s3">, None</span><span class="s1">)</span>
1834 <a name="l1814"><span class="ln">1814 </span></a>                    <span class="s1">key_fifo.append(key)</span>
1835 <a name="l1815"><span class="ln">1815 </span></a>
1836 <a name="l1816"><span class="ln">1816 </span></a>                <span class="s3">def </span><span class="s1">clear(self):</span>
1837 <a name="l1817"><span class="ln">1817 </span></a>                    <span class="s1">cache.clear()</span>
1838 <a name="l1818"><span class="ln">1818 </span></a>                    <span class="s1">key_fifo.clear()</span>
1839 <a name="l1819"><span class="ln">1819 </span></a>
1840 <a name="l1820"><span class="ln">1820 </span></a>                <span class="s3">def </span><span class="s1">cache_len(self):</span>
1841 <a name="l1821"><span class="ln">1821 </span></a>                    <span class="s3">return </span><span class="s1">len(cache)</span>
1842 <a name="l1822"><span class="ln">1822 </span></a>
1843 <a name="l1823"><span class="ln">1823 </span></a>                <span class="s1">self.get = types.MethodType(get</span><span class="s3">, </span><span class="s1">self)</span>
1844 <a name="l1824"><span class="ln">1824 </span></a>                <span class="s1">self.set = types.MethodType(set</span><span class="s3">, </span><span class="s1">self)</span>
1845 <a name="l1825"><span class="ln">1825 </span></a>                <span class="s1">self.clear = types.MethodType(clear</span><span class="s3">, </span><span class="s1">self)</span>
1846 <a name="l1826"><span class="ln">1826 </span></a>                <span class="s1">self.__len__ = types.MethodType(cache_len</span><span class="s3">, </span><span class="s1">self)</span>
1847 <a name="l1827"><span class="ln">1827 </span></a>
1848 <a name="l1828"><span class="ln">1828 </span></a>    <span class="s0"># argument cache for optimizing repeated calls when backtracking through recursive expressions</span>
1849 <a name="l1829"><span class="ln">1829 </span></a>    <span class="s1">packrat_cache = {} </span><span class="s0"># this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail</span>
1850 <a name="l1830"><span class="ln">1830 </span></a>    <span class="s1">packrat_cache_lock = RLock()</span>
1851 <a name="l1831"><span class="ln">1831 </span></a>    <span class="s1">packrat_cache_stats = [</span><span class="s4">0</span><span class="s3">, </span><span class="s4">0</span><span class="s1">]</span>
1852 <a name="l1832"><span class="ln">1832 </span></a>
1853 <a name="l1833"><span class="ln">1833 </span></a>    <span class="s0"># this method gets repeatedly called during backtracking with the same arguments -</span>
1854 <a name="l1834"><span class="ln">1834 </span></a>    <span class="s0"># we can cache these arguments and save ourselves the trouble of re-parsing the contained expression</span>
1855 <a name="l1835"><span class="ln">1835 </span></a>    <span class="s3">def </span><span class="s1">_parseCache(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True, </span><span class="s1">callPreParse=</span><span class="s3">True</span><span class="s1">):</span>
1856 <a name="l1836"><span class="ln">1836 </span></a>        <span class="s1">HIT</span><span class="s3">, </span><span class="s1">MISS = </span><span class="s4">0</span><span class="s3">, </span><span class="s4">1</span>
1857 <a name="l1837"><span class="ln">1837 </span></a>        <span class="s1">lookup = (self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">callPreParse</span><span class="s3">, </span><span class="s1">doActions)</span>
1858 <a name="l1838"><span class="ln">1838 </span></a>        <span class="s3">with </span><span class="s1">ParserElement.packrat_cache_lock:</span>
1859 <a name="l1839"><span class="ln">1839 </span></a>            <span class="s1">cache = ParserElement.packrat_cache</span>
1860 <a name="l1840"><span class="ln">1840 </span></a>            <span class="s1">value = cache.get(lookup)</span>
1861 <a name="l1841"><span class="ln">1841 </span></a>            <span class="s3">if </span><span class="s1">value </span><span class="s3">is </span><span class="s1">cache.not_in_cache:</span>
1862 <a name="l1842"><span class="ln">1842 </span></a>                <span class="s1">ParserElement.packrat_cache_stats[MISS] += </span><span class="s4">1</span>
1863 <a name="l1843"><span class="ln">1843 </span></a>                <span class="s3">try</span><span class="s1">:</span>
1864 <a name="l1844"><span class="ln">1844 </span></a>                    <span class="s1">value = self._parseNoCache(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse)</span>
1865 <a name="l1845"><span class="ln">1845 </span></a>                <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">pe:</span>
1866 <a name="l1846"><span class="ln">1846 </span></a>                    <span class="s0"># cache a copy of the exception, without the traceback</span>
1867 <a name="l1847"><span class="ln">1847 </span></a>                    <span class="s1">cache.set(lookup</span><span class="s3">, </span><span class="s1">pe.__class__(*pe.args))</span>
1868 <a name="l1848"><span class="ln">1848 </span></a>                    <span class="s3">raise</span>
1869 <a name="l1849"><span class="ln">1849 </span></a>                <span class="s3">else</span><span class="s1">:</span>
1870 <a name="l1850"><span class="ln">1850 </span></a>                    <span class="s1">cache.set(lookup</span><span class="s3">, </span><span class="s1">(value[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">value[</span><span class="s4">1</span><span class="s1">].copy()))</span>
1871 <a name="l1851"><span class="ln">1851 </span></a>                    <span class="s3">return </span><span class="s1">value</span>
1872 <a name="l1852"><span class="ln">1852 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1873 <a name="l1853"><span class="ln">1853 </span></a>                <span class="s1">ParserElement.packrat_cache_stats[HIT] += </span><span class="s4">1</span>
1874 <a name="l1854"><span class="ln">1854 </span></a>                <span class="s3">if </span><span class="s1">isinstance(value</span><span class="s3">, </span><span class="s1">Exception):</span>
1875 <a name="l1855"><span class="ln">1855 </span></a>                    <span class="s3">raise </span><span class="s1">value</span>
1876 <a name="l1856"><span class="ln">1856 </span></a>                <span class="s3">return </span><span class="s1">value[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">value[</span><span class="s4">1</span><span class="s1">].copy()</span>
1877 <a name="l1857"><span class="ln">1857 </span></a>
1878 <a name="l1858"><span class="ln">1858 </span></a>    <span class="s1">_parse = _parseNoCache</span>
1879 <a name="l1859"><span class="ln">1859 </span></a>
1880 <a name="l1860"><span class="ln">1860 </span></a>    <span class="s1">@staticmethod</span>
1881 <a name="l1861"><span class="ln">1861 </span></a>    <span class="s3">def </span><span class="s1">resetCache():</span>
1882 <a name="l1862"><span class="ln">1862 </span></a>        <span class="s1">ParserElement.packrat_cache.clear()</span>
1883 <a name="l1863"><span class="ln">1863 </span></a>        <span class="s1">ParserElement.packrat_cache_stats[:] = [</span><span class="s4">0</span><span class="s1">] * len(ParserElement.packrat_cache_stats)</span>
1884 <a name="l1864"><span class="ln">1864 </span></a>
1885 <a name="l1865"><span class="ln">1865 </span></a>    <span class="s1">_packratEnabled = </span><span class="s3">False</span>
1886 <a name="l1866"><span class="ln">1866 </span></a>    <span class="s1">@staticmethod</span>
1887 <a name="l1867"><span class="ln">1867 </span></a>    <span class="s3">def </span><span class="s1">enablePackrat(cache_size_limit=</span><span class="s4">128</span><span class="s1">):</span>
1888 <a name="l1868"><span class="ln">1868 </span></a>        <span class="s5">&quot;&quot;&quot;Enables &quot;packrat&quot; parsing, which adds memoizing to the parsing logic. 
1889 <a name="l1869"><span class="ln">1869 </span></a>           Repeated parse attempts at the same string location (which happens 
1890 <a name="l1870"><span class="ln">1870 </span></a>           often in many complex grammars) can immediately return a cached value, 
1891 <a name="l1871"><span class="ln">1871 </span></a>           instead of re-executing parsing/validating code.  Memoizing is done of 
1892 <a name="l1872"><span class="ln">1872 </span></a>           both valid results and parsing exceptions. 
1893 <a name="l1873"><span class="ln">1873 </span></a> 
1894 <a name="l1874"><span class="ln">1874 </span></a>           Parameters: 
1895 <a name="l1875"><span class="ln">1875 </span></a> 
1896 <a name="l1876"><span class="ln">1876 </span></a>           - cache_size_limit - (default= ``128``) - if an integer value is provided 
1897 <a name="l1877"><span class="ln">1877 </span></a>             will limit the size of the packrat cache; if None is passed, then 
1898 <a name="l1878"><span class="ln">1878 </span></a>             the cache size will be unbounded; if 0 is passed, the cache will 
1899 <a name="l1879"><span class="ln">1879 </span></a>             be effectively disabled. 
1900 <a name="l1880"><span class="ln">1880 </span></a> 
1901 <a name="l1881"><span class="ln">1881 </span></a>           This speedup may break existing programs that use parse actions that 
1902 <a name="l1882"><span class="ln">1882 </span></a>           have side-effects.  For this reason, packrat parsing is disabled when 
1903 <a name="l1883"><span class="ln">1883 </span></a>           you first import pyparsing.  To activate the packrat feature, your 
1904 <a name="l1884"><span class="ln">1884 </span></a>           program must call the class method :class:`ParserElement.enablePackrat`. 
1905 <a name="l1885"><span class="ln">1885 </span></a>           For best results, call ``enablePackrat()`` immediately after 
1906 <a name="l1886"><span class="ln">1886 </span></a>           importing pyparsing. 
1907 <a name="l1887"><span class="ln">1887 </span></a> 
1908 <a name="l1888"><span class="ln">1888 </span></a>           Example:: 
1909 <a name="l1889"><span class="ln">1889 </span></a> 
1910 <a name="l1890"><span class="ln">1890 </span></a>               from pip._vendor import pyparsing 
1911 <a name="l1891"><span class="ln">1891 </span></a>               pyparsing.ParserElement.enablePackrat() 
1912 <a name="l1892"><span class="ln">1892 </span></a>        &quot;&quot;&quot;</span>
1913 <a name="l1893"><span class="ln">1893 </span></a>        <span class="s3">if not </span><span class="s1">ParserElement._packratEnabled:</span>
1914 <a name="l1894"><span class="ln">1894 </span></a>            <span class="s1">ParserElement._packratEnabled = </span><span class="s3">True</span>
1915 <a name="l1895"><span class="ln">1895 </span></a>            <span class="s3">if </span><span class="s1">cache_size_limit </span><span class="s3">is None</span><span class="s1">:</span>
1916 <a name="l1896"><span class="ln">1896 </span></a>                <span class="s1">ParserElement.packrat_cache = ParserElement._UnboundedCache()</span>
1917 <a name="l1897"><span class="ln">1897 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1918 <a name="l1898"><span class="ln">1898 </span></a>                <span class="s1">ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)</span>
1919 <a name="l1899"><span class="ln">1899 </span></a>            <span class="s1">ParserElement._parse = ParserElement._parseCache</span>
1920 <a name="l1900"><span class="ln">1900 </span></a>
1921 <a name="l1901"><span class="ln">1901 </span></a>    <span class="s3">def </span><span class="s1">parseString(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">parseAll=</span><span class="s3">False</span><span class="s1">):</span>
1922 <a name="l1902"><span class="ln">1902 </span></a>        <span class="s5">&quot;&quot;&quot; 
1923 <a name="l1903"><span class="ln">1903 </span></a>        Execute the parse expression with the given string. 
1924 <a name="l1904"><span class="ln">1904 </span></a>        This is the main interface to the client code, once the complete 
1925 <a name="l1905"><span class="ln">1905 </span></a>        expression has been built. 
1926 <a name="l1906"><span class="ln">1906 </span></a> 
1927 <a name="l1907"><span class="ln">1907 </span></a>        Returns the parsed data as a :class:`ParseResults` object, which may be 
1928 <a name="l1908"><span class="ln">1908 </span></a>        accessed as a list, or as a dict or object with attributes if the given parser 
1929 <a name="l1909"><span class="ln">1909 </span></a>        includes results names. 
1930 <a name="l1910"><span class="ln">1910 </span></a> 
1931 <a name="l1911"><span class="ln">1911 </span></a>        If you want the grammar to require that the entire input string be 
1932 <a name="l1912"><span class="ln">1912 </span></a>        successfully parsed, then set ``parseAll`` to True (equivalent to ending 
1933 <a name="l1913"><span class="ln">1913 </span></a>        the grammar with ``StringEnd()``). 
1934 <a name="l1914"><span class="ln">1914 </span></a> 
1935 <a name="l1915"><span class="ln">1915 </span></a>        Note: ``parseString`` implicitly calls ``expandtabs()`` on the input string, 
1936 <a name="l1916"><span class="ln">1916 </span></a>        in order to report proper column numbers in parse actions. 
1937 <a name="l1917"><span class="ln">1917 </span></a>        If the input string contains tabs and 
1938 <a name="l1918"><span class="ln">1918 </span></a>        the grammar uses parse actions that use the ``loc`` argument to index into the 
1939 <a name="l1919"><span class="ln">1919 </span></a>        string being parsed, you can ensure you have a consistent view of the input 
1940 <a name="l1920"><span class="ln">1920 </span></a>        string by: 
1941 <a name="l1921"><span class="ln">1921 </span></a> 
1942 <a name="l1922"><span class="ln">1922 </span></a>        - calling ``parseWithTabs`` on your grammar before calling ``parseString`` 
1943 <a name="l1923"><span class="ln">1923 </span></a>          (see :class:`parseWithTabs`) 
1944 <a name="l1924"><span class="ln">1924 </span></a>        - define your parse action using the full ``(s, loc, toks)`` signature, and 
1945 <a name="l1925"><span class="ln">1925 </span></a>          reference the input string using the parse action's ``s`` argument 
1946 <a name="l1926"><span class="ln">1926 </span></a>        - explictly expand the tabs in your input string before calling 
1947 <a name="l1927"><span class="ln">1927 </span></a>          ``parseString`` 
1948 <a name="l1928"><span class="ln">1928 </span></a> 
1949 <a name="l1929"><span class="ln">1929 </span></a>        Example:: 
1950 <a name="l1930"><span class="ln">1930 </span></a> 
1951 <a name="l1931"><span class="ln">1931 </span></a>            Word('a').parseString('aaaaabaaa')  # -&gt; ['aaaaa'] 
1952 <a name="l1932"><span class="ln">1932 </span></a>            Word('a').parseString('aaaaabaaa', parseAll=True)  # -&gt; Exception: Expected end of text 
1953 <a name="l1933"><span class="ln">1933 </span></a>        &quot;&quot;&quot;</span>
1954 <a name="l1934"><span class="ln">1934 </span></a>        <span class="s1">ParserElement.resetCache()</span>
1955 <a name="l1935"><span class="ln">1935 </span></a>        <span class="s3">if not </span><span class="s1">self.streamlined:</span>
1956 <a name="l1936"><span class="ln">1936 </span></a>            <span class="s1">self.streamline()</span>
1957 <a name="l1937"><span class="ln">1937 </span></a>            <span class="s0"># ~ self.saveAsList = True</span>
1958 <a name="l1938"><span class="ln">1938 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.ignoreExprs:</span>
1959 <a name="l1939"><span class="ln">1939 </span></a>            <span class="s1">e.streamline()</span>
1960 <a name="l1940"><span class="ln">1940 </span></a>        <span class="s3">if not </span><span class="s1">self.keepTabs:</span>
1961 <a name="l1941"><span class="ln">1941 </span></a>            <span class="s1">instring = instring.expandtabs()</span>
1962 <a name="l1942"><span class="ln">1942 </span></a>        <span class="s3">try</span><span class="s1">:</span>
1963 <a name="l1943"><span class="ln">1943 </span></a>            <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self._parse(instring</span><span class="s3">, </span><span class="s4">0</span><span class="s1">)</span>
1964 <a name="l1944"><span class="ln">1944 </span></a>            <span class="s3">if </span><span class="s1">parseAll:</span>
1965 <a name="l1945"><span class="ln">1945 </span></a>                <span class="s1">loc = self.preParse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1966 <a name="l1946"><span class="ln">1946 </span></a>                <span class="s1">se = Empty() + StringEnd()</span>
1967 <a name="l1947"><span class="ln">1947 </span></a>                <span class="s1">se._parse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
1968 <a name="l1948"><span class="ln">1948 </span></a>        <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">exc:</span>
1969 <a name="l1949"><span class="ln">1949 </span></a>            <span class="s3">if </span><span class="s1">ParserElement.verbose_stacktrace:</span>
1970 <a name="l1950"><span class="ln">1950 </span></a>                <span class="s3">raise</span>
1971 <a name="l1951"><span class="ln">1951 </span></a>            <span class="s3">else</span><span class="s1">:</span>
1972 <a name="l1952"><span class="ln">1952 </span></a>                <span class="s0"># catch and re-raise exception from here, clearing out pyparsing internal stack trace</span>
1973 <a name="l1953"><span class="ln">1953 </span></a>                <span class="s3">if </span><span class="s1">getattr(exc</span><span class="s3">, </span><span class="s2">'__traceback__'</span><span class="s3">, None</span><span class="s1">) </span><span class="s3">is not None</span><span class="s1">:</span>
1974 <a name="l1954"><span class="ln">1954 </span></a>                    <span class="s1">exc.__traceback__ = self._trim_traceback(exc.__traceback__)</span>
1975 <a name="l1955"><span class="ln">1955 </span></a>                <span class="s3">raise </span><span class="s1">exc</span>
1976 <a name="l1956"><span class="ln">1956 </span></a>        <span class="s3">else</span><span class="s1">:</span>
1977 <a name="l1957"><span class="ln">1957 </span></a>            <span class="s3">return </span><span class="s1">tokens</span>
1978 <a name="l1958"><span class="ln">1958 </span></a>
1979 <a name="l1959"><span class="ln">1959 </span></a>    <span class="s3">def </span><span class="s1">scanString(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">maxMatches=_MAX_INT</span><span class="s3">, </span><span class="s1">overlap=</span><span class="s3">False</span><span class="s1">):</span>
1980 <a name="l1960"><span class="ln">1960 </span></a>        <span class="s5">&quot;&quot;&quot; 
1981 <a name="l1961"><span class="ln">1961 </span></a>        Scan the input string for expression matches.  Each match will return the 
1982 <a name="l1962"><span class="ln">1962 </span></a>        matching tokens, start location, and end location.  May be called with optional 
1983 <a name="l1963"><span class="ln">1963 </span></a>        ``maxMatches`` argument, to clip scanning after 'n' matches are found.  If 
1984 <a name="l1964"><span class="ln">1964 </span></a>        ``overlap`` is specified, then overlapping matches will be reported. 
1985 <a name="l1965"><span class="ln">1965 </span></a> 
1986 <a name="l1966"><span class="ln">1966 </span></a>        Note that the start and end locations are reported relative to the string 
1987 <a name="l1967"><span class="ln">1967 </span></a>        being parsed.  See :class:`parseString` for more information on parsing 
1988 <a name="l1968"><span class="ln">1968 </span></a>        strings with embedded tabs. 
1989 <a name="l1969"><span class="ln">1969 </span></a> 
1990 <a name="l1970"><span class="ln">1970 </span></a>        Example:: 
1991 <a name="l1971"><span class="ln">1971 </span></a> 
1992 <a name="l1972"><span class="ln">1972 </span></a>            source = &quot;sldjf123lsdjjkf345sldkjf879lkjsfd987&quot; 
1993 <a name="l1973"><span class="ln">1973 </span></a>            print(source) 
1994 <a name="l1974"><span class="ln">1974 </span></a>            for tokens, start, end in Word(alphas).scanString(source): 
1995 <a name="l1975"><span class="ln">1975 </span></a>                print(' '*start + '^'*(end-start)) 
1996 <a name="l1976"><span class="ln">1976 </span></a>                print(' '*start + tokens[0]) 
1997 <a name="l1977"><span class="ln">1977 </span></a> 
1998 <a name="l1978"><span class="ln">1978 </span></a>        prints:: 
1999 <a name="l1979"><span class="ln">1979 </span></a> 
2000 <a name="l1980"><span class="ln">1980 </span></a>            sldjf123lsdjjkf345sldkjf879lkjsfd987 
2001 <a name="l1981"><span class="ln">1981 </span></a>            ^^^^^ 
2002 <a name="l1982"><span class="ln">1982 </span></a>            sldjf 
2003 <a name="l1983"><span class="ln">1983 </span></a>                    ^^^^^^^ 
2004 <a name="l1984"><span class="ln">1984 </span></a>                    lsdjjkf 
2005 <a name="l1985"><span class="ln">1985 </span></a>                              ^^^^^^ 
2006 <a name="l1986"><span class="ln">1986 </span></a>                              sldkjf 
2007 <a name="l1987"><span class="ln">1987 </span></a>                                       ^^^^^^ 
2008 <a name="l1988"><span class="ln">1988 </span></a>                                       lkjsfd 
2009 <a name="l1989"><span class="ln">1989 </span></a>        &quot;&quot;&quot;</span>
2010 <a name="l1990"><span class="ln">1990 </span></a>        <span class="s3">if not </span><span class="s1">self.streamlined:</span>
2011 <a name="l1991"><span class="ln">1991 </span></a>            <span class="s1">self.streamline()</span>
2012 <a name="l1992"><span class="ln">1992 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.ignoreExprs:</span>
2013 <a name="l1993"><span class="ln">1993 </span></a>            <span class="s1">e.streamline()</span>
2014 <a name="l1994"><span class="ln">1994 </span></a>
2015 <a name="l1995"><span class="ln">1995 </span></a>        <span class="s3">if not </span><span class="s1">self.keepTabs:</span>
2016 <a name="l1996"><span class="ln">1996 </span></a>            <span class="s1">instring = _ustr(instring).expandtabs()</span>
2017 <a name="l1997"><span class="ln">1997 </span></a>        <span class="s1">instrlen = len(instring)</span>
2018 <a name="l1998"><span class="ln">1998 </span></a>        <span class="s1">loc = </span><span class="s4">0</span>
2019 <a name="l1999"><span class="ln">1999 </span></a>        <span class="s1">preparseFn = self.preParse</span>
2020 <a name="l2000"><span class="ln">2000 </span></a>        <span class="s1">parseFn = self._parse</span>
2021 <a name="l2001"><span class="ln">2001 </span></a>        <span class="s1">ParserElement.resetCache()</span>
2022 <a name="l2002"><span class="ln">2002 </span></a>        <span class="s1">matches = </span><span class="s4">0</span>
2023 <a name="l2003"><span class="ln">2003 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2024 <a name="l2004"><span class="ln">2004 </span></a>            <span class="s3">while </span><span class="s1">loc &lt;= instrlen </span><span class="s3">and </span><span class="s1">matches &lt; maxMatches:</span>
2025 <a name="l2005"><span class="ln">2005 </span></a>                <span class="s3">try</span><span class="s1">:</span>
2026 <a name="l2006"><span class="ln">2006 </span></a>                    <span class="s1">preloc = preparseFn(instring</span><span class="s3">, </span><span class="s1">loc)</span>
2027 <a name="l2007"><span class="ln">2007 </span></a>                    <span class="s1">nextLoc</span><span class="s3">, </span><span class="s1">tokens = parseFn(instring</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
2028 <a name="l2008"><span class="ln">2008 </span></a>                <span class="s3">except </span><span class="s1">ParseException:</span>
2029 <a name="l2009"><span class="ln">2009 </span></a>                    <span class="s1">loc = preloc + </span><span class="s4">1</span>
2030 <a name="l2010"><span class="ln">2010 </span></a>                <span class="s3">else</span><span class="s1">:</span>
2031 <a name="l2011"><span class="ln">2011 </span></a>                    <span class="s3">if </span><span class="s1">nextLoc &gt; loc:</span>
2032 <a name="l2012"><span class="ln">2012 </span></a>                        <span class="s1">matches += </span><span class="s4">1</span>
2033 <a name="l2013"><span class="ln">2013 </span></a>                        <span class="s3">yield </span><span class="s1">tokens</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">nextLoc</span>
2034 <a name="l2014"><span class="ln">2014 </span></a>                        <span class="s3">if </span><span class="s1">overlap:</span>
2035 <a name="l2015"><span class="ln">2015 </span></a>                            <span class="s1">nextloc = preparseFn(instring</span><span class="s3">, </span><span class="s1">loc)</span>
2036 <a name="l2016"><span class="ln">2016 </span></a>                            <span class="s3">if </span><span class="s1">nextloc &gt; loc:</span>
2037 <a name="l2017"><span class="ln">2017 </span></a>                                <span class="s1">loc = nextLoc</span>
2038 <a name="l2018"><span class="ln">2018 </span></a>                            <span class="s3">else</span><span class="s1">:</span>
2039 <a name="l2019"><span class="ln">2019 </span></a>                                <span class="s1">loc += </span><span class="s4">1</span>
2040 <a name="l2020"><span class="ln">2020 </span></a>                        <span class="s3">else</span><span class="s1">:</span>
2041 <a name="l2021"><span class="ln">2021 </span></a>                            <span class="s1">loc = nextLoc</span>
2042 <a name="l2022"><span class="ln">2022 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
2043 <a name="l2023"><span class="ln">2023 </span></a>                        <span class="s1">loc = preloc + </span><span class="s4">1</span>
2044 <a name="l2024"><span class="ln">2024 </span></a>        <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">exc:</span>
2045 <a name="l2025"><span class="ln">2025 </span></a>            <span class="s3">if </span><span class="s1">ParserElement.verbose_stacktrace:</span>
2046 <a name="l2026"><span class="ln">2026 </span></a>                <span class="s3">raise</span>
2047 <a name="l2027"><span class="ln">2027 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2048 <a name="l2028"><span class="ln">2028 </span></a>                <span class="s0"># catch and re-raise exception from here, clearing out pyparsing internal stack trace</span>
2049 <a name="l2029"><span class="ln">2029 </span></a>                <span class="s3">if </span><span class="s1">getattr(exc</span><span class="s3">, </span><span class="s2">'__traceback__'</span><span class="s3">, None</span><span class="s1">) </span><span class="s3">is not None</span><span class="s1">:</span>
2050 <a name="l2030"><span class="ln">2030 </span></a>                    <span class="s1">exc.__traceback__ = self._trim_traceback(exc.__traceback__)</span>
2051 <a name="l2031"><span class="ln">2031 </span></a>                <span class="s3">raise </span><span class="s1">exc</span>
2052 <a name="l2032"><span class="ln">2032 </span></a>
2053 <a name="l2033"><span class="ln">2033 </span></a>    <span class="s3">def </span><span class="s1">transformString(self</span><span class="s3">, </span><span class="s1">instring):</span>
2054 <a name="l2034"><span class="ln">2034 </span></a>        <span class="s5">&quot;&quot;&quot; 
2055 <a name="l2035"><span class="ln">2035 </span></a>        Extension to :class:`scanString`, to modify matching text with modified tokens that may 
2056 <a name="l2036"><span class="ln">2036 </span></a>        be returned from a parse action.  To use ``transformString``, define a grammar and 
2057 <a name="l2037"><span class="ln">2037 </span></a>        attach a parse action to it that modifies the returned token list. 
2058 <a name="l2038"><span class="ln">2038 </span></a>        Invoking ``transformString()`` on a target string will then scan for matches, 
2059 <a name="l2039"><span class="ln">2039 </span></a>        and replace the matched text patterns according to the logic in the parse 
2060 <a name="l2040"><span class="ln">2040 </span></a>        action.  ``transformString()`` returns the resulting transformed string. 
2061 <a name="l2041"><span class="ln">2041 </span></a> 
2062 <a name="l2042"><span class="ln">2042 </span></a>        Example:: 
2063 <a name="l2043"><span class="ln">2043 </span></a> 
2064 <a name="l2044"><span class="ln">2044 </span></a>            wd = Word(alphas) 
2065 <a name="l2045"><span class="ln">2045 </span></a>            wd.setParseAction(lambda toks: toks[0].title()) 
2066 <a name="l2046"><span class="ln">2046 </span></a> 
2067 <a name="l2047"><span class="ln">2047 </span></a>            print(wd.transformString(&quot;now is the winter of our discontent made glorious summer by this sun of york.&quot;)) 
2068 <a name="l2048"><span class="ln">2048 </span></a> 
2069 <a name="l2049"><span class="ln">2049 </span></a>        prints:: 
2070 <a name="l2050"><span class="ln">2050 </span></a> 
2071 <a name="l2051"><span class="ln">2051 </span></a>            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York. 
2072 <a name="l2052"><span class="ln">2052 </span></a>        &quot;&quot;&quot;</span>
2073 <a name="l2053"><span class="ln">2053 </span></a>        <span class="s1">out = []</span>
2074 <a name="l2054"><span class="ln">2054 </span></a>        <span class="s1">lastE = </span><span class="s4">0</span>
2075 <a name="l2055"><span class="ln">2055 </span></a>        <span class="s0"># force preservation of &lt;TAB&gt;s, to minimize unwanted transformation of string, and to</span>
2076 <a name="l2056"><span class="ln">2056 </span></a>        <span class="s0"># keep string locs straight between transformString and scanString</span>
2077 <a name="l2057"><span class="ln">2057 </span></a>        <span class="s1">self.keepTabs = </span><span class="s3">True</span>
2078 <a name="l2058"><span class="ln">2058 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2079 <a name="l2059"><span class="ln">2059 </span></a>            <span class="s3">for </span><span class="s1">t</span><span class="s3">, </span><span class="s1">s</span><span class="s3">, </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.scanString(instring):</span>
2080 <a name="l2060"><span class="ln">2060 </span></a>                <span class="s1">out.append(instring[lastE:s])</span>
2081 <a name="l2061"><span class="ln">2061 </span></a>                <span class="s3">if </span><span class="s1">t:</span>
2082 <a name="l2062"><span class="ln">2062 </span></a>                    <span class="s3">if </span><span class="s1">isinstance(t</span><span class="s3">, </span><span class="s1">ParseResults):</span>
2083 <a name="l2063"><span class="ln">2063 </span></a>                        <span class="s1">out += t.asList()</span>
2084 <a name="l2064"><span class="ln">2064 </span></a>                    <span class="s3">elif </span><span class="s1">isinstance(t</span><span class="s3">, </span><span class="s1">list):</span>
2085 <a name="l2065"><span class="ln">2065 </span></a>                        <span class="s1">out += t</span>
2086 <a name="l2066"><span class="ln">2066 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
2087 <a name="l2067"><span class="ln">2067 </span></a>                        <span class="s1">out.append(t)</span>
2088 <a name="l2068"><span class="ln">2068 </span></a>                <span class="s1">lastE = e</span>
2089 <a name="l2069"><span class="ln">2069 </span></a>            <span class="s1">out.append(instring[lastE:])</span>
2090 <a name="l2070"><span class="ln">2070 </span></a>            <span class="s1">out = [o </span><span class="s3">for </span><span class="s1">o </span><span class="s3">in </span><span class="s1">out </span><span class="s3">if </span><span class="s1">o]</span>
2091 <a name="l2071"><span class="ln">2071 </span></a>            <span class="s3">return </span><span class="s2">&quot;&quot;</span><span class="s1">.join(map(_ustr</span><span class="s3">, </span><span class="s1">_flatten(out)))</span>
2092 <a name="l2072"><span class="ln">2072 </span></a>        <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">exc:</span>
2093 <a name="l2073"><span class="ln">2073 </span></a>            <span class="s3">if </span><span class="s1">ParserElement.verbose_stacktrace:</span>
2094 <a name="l2074"><span class="ln">2074 </span></a>                <span class="s3">raise</span>
2095 <a name="l2075"><span class="ln">2075 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2096 <a name="l2076"><span class="ln">2076 </span></a>                <span class="s0"># catch and re-raise exception from here, clearing out pyparsing internal stack trace</span>
2097 <a name="l2077"><span class="ln">2077 </span></a>                <span class="s3">if </span><span class="s1">getattr(exc</span><span class="s3">, </span><span class="s2">'__traceback__'</span><span class="s3">, None</span><span class="s1">) </span><span class="s3">is not None</span><span class="s1">:</span>
2098 <a name="l2078"><span class="ln">2078 </span></a>                    <span class="s1">exc.__traceback__ = self._trim_traceback(exc.__traceback__)</span>
2099 <a name="l2079"><span class="ln">2079 </span></a>                <span class="s3">raise </span><span class="s1">exc</span>
2100 <a name="l2080"><span class="ln">2080 </span></a>
2101 <a name="l2081"><span class="ln">2081 </span></a>    <span class="s3">def </span><span class="s1">searchString(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">maxMatches=_MAX_INT):</span>
2102 <a name="l2082"><span class="ln">2082 </span></a>        <span class="s5">&quot;&quot;&quot; 
2103 <a name="l2083"><span class="ln">2083 </span></a>        Another extension to :class:`scanString`, simplifying the access to the tokens found 
2104 <a name="l2084"><span class="ln">2084 </span></a>        to match the given parse expression.  May be called with optional 
2105 <a name="l2085"><span class="ln">2085 </span></a>        ``maxMatches`` argument, to clip searching after 'n' matches are found. 
2106 <a name="l2086"><span class="ln">2086 </span></a> 
2107 <a name="l2087"><span class="ln">2087 </span></a>        Example:: 
2108 <a name="l2088"><span class="ln">2088 </span></a> 
2109 <a name="l2089"><span class="ln">2089 </span></a>            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters 
2110 <a name="l2090"><span class="ln">2090 </span></a>            cap_word = Word(alphas.upper(), alphas.lower()) 
2111 <a name="l2091"><span class="ln">2091 </span></a> 
2112 <a name="l2092"><span class="ln">2092 </span></a>            print(cap_word.searchString(&quot;More than Iron, more than Lead, more than Gold I need Electricity&quot;)) 
2113 <a name="l2093"><span class="ln">2093 </span></a> 
2114 <a name="l2094"><span class="ln">2094 </span></a>            # the sum() builtin can be used to merge results into a single ParseResults object 
2115 <a name="l2095"><span class="ln">2095 </span></a>            print(sum(cap_word.searchString(&quot;More than Iron, more than Lead, more than Gold I need Electricity&quot;))) 
2116 <a name="l2096"><span class="ln">2096 </span></a> 
2117 <a name="l2097"><span class="ln">2097 </span></a>        prints:: 
2118 <a name="l2098"><span class="ln">2098 </span></a> 
2119 <a name="l2099"><span class="ln">2099 </span></a>            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']] 
2120 <a name="l2100"><span class="ln">2100 </span></a>            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity'] 
2121 <a name="l2101"><span class="ln">2101 </span></a>        &quot;&quot;&quot;</span>
2122 <a name="l2102"><span class="ln">2102 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2123 <a name="l2103"><span class="ln">2103 </span></a>            <span class="s3">return </span><span class="s1">ParseResults([t </span><span class="s3">for </span><span class="s1">t</span><span class="s3">, </span><span class="s1">s</span><span class="s3">, </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.scanString(instring</span><span class="s3">, </span><span class="s1">maxMatches)])</span>
2124 <a name="l2104"><span class="ln">2104 </span></a>        <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">exc:</span>
2125 <a name="l2105"><span class="ln">2105 </span></a>            <span class="s3">if </span><span class="s1">ParserElement.verbose_stacktrace:</span>
2126 <a name="l2106"><span class="ln">2106 </span></a>                <span class="s3">raise</span>
2127 <a name="l2107"><span class="ln">2107 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2128 <a name="l2108"><span class="ln">2108 </span></a>                <span class="s0"># catch and re-raise exception from here, clearing out pyparsing internal stack trace</span>
2129 <a name="l2109"><span class="ln">2109 </span></a>                <span class="s3">if </span><span class="s1">getattr(exc</span><span class="s3">, </span><span class="s2">'__traceback__'</span><span class="s3">, None</span><span class="s1">) </span><span class="s3">is not None</span><span class="s1">:</span>
2130 <a name="l2110"><span class="ln">2110 </span></a>                    <span class="s1">exc.__traceback__ = self._trim_traceback(exc.__traceback__)</span>
2131 <a name="l2111"><span class="ln">2111 </span></a>                <span class="s3">raise </span><span class="s1">exc</span>
2132 <a name="l2112"><span class="ln">2112 </span></a>
2133 <a name="l2113"><span class="ln">2113 </span></a>    <span class="s3">def </span><span class="s1">split(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">maxsplit=_MAX_INT</span><span class="s3">, </span><span class="s1">includeSeparators=</span><span class="s3">False</span><span class="s1">):</span>
2134 <a name="l2114"><span class="ln">2114 </span></a>        <span class="s5">&quot;&quot;&quot; 
2135 <a name="l2115"><span class="ln">2115 </span></a>        Generator method to split a string using the given expression as a separator. 
2136 <a name="l2116"><span class="ln">2116 </span></a>        May be called with optional ``maxsplit`` argument, to limit the number of splits; 
2137 <a name="l2117"><span class="ln">2117 </span></a>        and the optional ``includeSeparators`` argument (default= ``False``), if the separating 
2138 <a name="l2118"><span class="ln">2118 </span></a>        matching text should be included in the split results. 
2139 <a name="l2119"><span class="ln">2119 </span></a> 
2140 <a name="l2120"><span class="ln">2120 </span></a>        Example:: 
2141 <a name="l2121"><span class="ln">2121 </span></a> 
2142 <a name="l2122"><span class="ln">2122 </span></a>            punc = oneOf(list(&quot;.,;:/-!?&quot;)) 
2143 <a name="l2123"><span class="ln">2123 </span></a>            print(list(punc.split(&quot;This, this?, this sentence, is badly punctuated!&quot;))) 
2144 <a name="l2124"><span class="ln">2124 </span></a> 
2145 <a name="l2125"><span class="ln">2125 </span></a>        prints:: 
2146 <a name="l2126"><span class="ln">2126 </span></a> 
2147 <a name="l2127"><span class="ln">2127 </span></a>            ['This', ' this', '', ' this sentence', ' is badly punctuated', ''] 
2148 <a name="l2128"><span class="ln">2128 </span></a>        &quot;&quot;&quot;</span>
2149 <a name="l2129"><span class="ln">2129 </span></a>        <span class="s1">splits = </span><span class="s4">0</span>
2150 <a name="l2130"><span class="ln">2130 </span></a>        <span class="s1">last = </span><span class="s4">0</span>
2151 <a name="l2131"><span class="ln">2131 </span></a>        <span class="s3">for </span><span class="s1">t</span><span class="s3">, </span><span class="s1">s</span><span class="s3">, </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.scanString(instring</span><span class="s3">, </span><span class="s1">maxMatches=maxsplit):</span>
2152 <a name="l2132"><span class="ln">2132 </span></a>            <span class="s3">yield </span><span class="s1">instring[last:s]</span>
2153 <a name="l2133"><span class="ln">2133 </span></a>            <span class="s3">if </span><span class="s1">includeSeparators:</span>
2154 <a name="l2134"><span class="ln">2134 </span></a>                <span class="s3">yield </span><span class="s1">t[</span><span class="s4">0</span><span class="s1">]</span>
2155 <a name="l2135"><span class="ln">2135 </span></a>            <span class="s1">last = e</span>
2156 <a name="l2136"><span class="ln">2136 </span></a>        <span class="s3">yield </span><span class="s1">instring[last:]</span>
2157 <a name="l2137"><span class="ln">2137 </span></a>
2158 <a name="l2138"><span class="ln">2138 </span></a>    <span class="s3">def </span><span class="s1">__add__(self</span><span class="s3">, </span><span class="s1">other):</span>
2159 <a name="l2139"><span class="ln">2139 </span></a>        <span class="s5">&quot;&quot;&quot; 
2160 <a name="l2140"><span class="ln">2140 </span></a>        Implementation of + operator - returns :class:`And`. Adding strings to a ParserElement 
2161 <a name="l2141"><span class="ln">2141 </span></a>        converts them to :class:`Literal`s by default. 
2162 <a name="l2142"><span class="ln">2142 </span></a> 
2163 <a name="l2143"><span class="ln">2143 </span></a>        Example:: 
2164 <a name="l2144"><span class="ln">2144 </span></a> 
2165 <a name="l2145"><span class="ln">2145 </span></a>            greet = Word(alphas) + &quot;,&quot; + Word(alphas) + &quot;!&quot; 
2166 <a name="l2146"><span class="ln">2146 </span></a>            hello = &quot;Hello, World!&quot; 
2167 <a name="l2147"><span class="ln">2147 </span></a>            print (hello, &quot;-&gt;&quot;, greet.parseString(hello)) 
2168 <a name="l2148"><span class="ln">2148 </span></a> 
2169 <a name="l2149"><span class="ln">2149 </span></a>        prints:: 
2170 <a name="l2150"><span class="ln">2150 </span></a> 
2171 <a name="l2151"><span class="ln">2151 </span></a>            Hello, World! -&gt; ['Hello', ',', 'World', '!'] 
2172 <a name="l2152"><span class="ln">2152 </span></a> 
2173 <a name="l2153"><span class="ln">2153 </span></a>        ``...`` may be used as a parse expression as a short form of :class:`SkipTo`. 
2174 <a name="l2154"><span class="ln">2154 </span></a> 
2175 <a name="l2155"><span class="ln">2155 </span></a>            Literal('start') + ... + Literal('end') 
2176 <a name="l2156"><span class="ln">2156 </span></a> 
2177 <a name="l2157"><span class="ln">2157 </span></a>        is equivalent to: 
2178 <a name="l2158"><span class="ln">2158 </span></a> 
2179 <a name="l2159"><span class="ln">2159 </span></a>            Literal('start') + SkipTo('end')(&quot;_skipped*&quot;) + Literal('end') 
2180 <a name="l2160"><span class="ln">2160 </span></a> 
2181 <a name="l2161"><span class="ln">2161 </span></a>        Note that the skipped text is returned with '_skipped' as a results name, 
2182 <a name="l2162"><span class="ln">2162 </span></a>        and to support having multiple skips in the same parser, the value returned is 
2183 <a name="l2163"><span class="ln">2163 </span></a>        a list of all skipped text. 
2184 <a name="l2164"><span class="ln">2164 </span></a>        &quot;&quot;&quot;</span>
2185 <a name="l2165"><span class="ln">2165 </span></a>        <span class="s3">if </span><span class="s1">other </span><span class="s3">is </span><span class="s1">Ellipsis:</span>
2186 <a name="l2166"><span class="ln">2166 </span></a>            <span class="s3">return </span><span class="s1">_PendingSkip(self)</span>
2187 <a name="l2167"><span class="ln">2167 </span></a>
2188 <a name="l2168"><span class="ln">2168 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2189 <a name="l2169"><span class="ln">2169 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2190 <a name="l2170"><span class="ln">2170 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2191 <a name="l2171"><span class="ln">2171 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2192 <a name="l2172"><span class="ln">2172 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2193 <a name="l2173"><span class="ln">2173 </span></a>            <span class="s3">return None</span>
2194 <a name="l2174"><span class="ln">2174 </span></a>        <span class="s3">return </span><span class="s1">And([self</span><span class="s3">, </span><span class="s1">other])</span>
2195 <a name="l2175"><span class="ln">2175 </span></a>
2196 <a name="l2176"><span class="ln">2176 </span></a>    <span class="s3">def </span><span class="s1">__radd__(self</span><span class="s3">, </span><span class="s1">other):</span>
2197 <a name="l2177"><span class="ln">2177 </span></a>        <span class="s5">&quot;&quot;&quot; 
2198 <a name="l2178"><span class="ln">2178 </span></a>        Implementation of + operator when left operand is not a :class:`ParserElement` 
2199 <a name="l2179"><span class="ln">2179 </span></a>        &quot;&quot;&quot;</span>
2200 <a name="l2180"><span class="ln">2180 </span></a>        <span class="s3">if </span><span class="s1">other </span><span class="s3">is </span><span class="s1">Ellipsis:</span>
2201 <a name="l2181"><span class="ln">2181 </span></a>            <span class="s3">return </span><span class="s1">SkipTo(self)(</span><span class="s2">&quot;_skipped*&quot;</span><span class="s1">) + self</span>
2202 <a name="l2182"><span class="ln">2182 </span></a>
2203 <a name="l2183"><span class="ln">2183 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2204 <a name="l2184"><span class="ln">2184 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2205 <a name="l2185"><span class="ln">2185 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2206 <a name="l2186"><span class="ln">2186 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2207 <a name="l2187"><span class="ln">2187 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2208 <a name="l2188"><span class="ln">2188 </span></a>            <span class="s3">return None</span>
2209 <a name="l2189"><span class="ln">2189 </span></a>        <span class="s3">return </span><span class="s1">other + self</span>
2210 <a name="l2190"><span class="ln">2190 </span></a>
2211 <a name="l2191"><span class="ln">2191 </span></a>    <span class="s3">def </span><span class="s1">__sub__(self</span><span class="s3">, </span><span class="s1">other):</span>
2212 <a name="l2192"><span class="ln">2192 </span></a>        <span class="s5">&quot;&quot;&quot; 
2213 <a name="l2193"><span class="ln">2193 </span></a>        Implementation of - operator, returns :class:`And` with error stop 
2214 <a name="l2194"><span class="ln">2194 </span></a>        &quot;&quot;&quot;</span>
2215 <a name="l2195"><span class="ln">2195 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2216 <a name="l2196"><span class="ln">2196 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2217 <a name="l2197"><span class="ln">2197 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2218 <a name="l2198"><span class="ln">2198 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2219 <a name="l2199"><span class="ln">2199 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2220 <a name="l2200"><span class="ln">2200 </span></a>            <span class="s3">return None</span>
2221 <a name="l2201"><span class="ln">2201 </span></a>        <span class="s3">return </span><span class="s1">self + And._ErrorStop() + other</span>
2222 <a name="l2202"><span class="ln">2202 </span></a>
2223 <a name="l2203"><span class="ln">2203 </span></a>    <span class="s3">def </span><span class="s1">__rsub__(self</span><span class="s3">, </span><span class="s1">other):</span>
2224 <a name="l2204"><span class="ln">2204 </span></a>        <span class="s5">&quot;&quot;&quot; 
2225 <a name="l2205"><span class="ln">2205 </span></a>        Implementation of - operator when left operand is not a :class:`ParserElement` 
2226 <a name="l2206"><span class="ln">2206 </span></a>        &quot;&quot;&quot;</span>
2227 <a name="l2207"><span class="ln">2207 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2228 <a name="l2208"><span class="ln">2208 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2229 <a name="l2209"><span class="ln">2209 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2230 <a name="l2210"><span class="ln">2210 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2231 <a name="l2211"><span class="ln">2211 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2232 <a name="l2212"><span class="ln">2212 </span></a>            <span class="s3">return None</span>
2233 <a name="l2213"><span class="ln">2213 </span></a>        <span class="s3">return </span><span class="s1">other - self</span>
2234 <a name="l2214"><span class="ln">2214 </span></a>
2235 <a name="l2215"><span class="ln">2215 </span></a>    <span class="s3">def </span><span class="s1">__mul__(self</span><span class="s3">, </span><span class="s1">other):</span>
2236 <a name="l2216"><span class="ln">2216 </span></a>        <span class="s5">&quot;&quot;&quot; 
2237 <a name="l2217"><span class="ln">2217 </span></a>        Implementation of * operator, allows use of ``expr * 3`` in place of 
2238 <a name="l2218"><span class="ln">2218 </span></a>        ``expr + expr + expr``.  Expressions may also me multiplied by a 2-integer 
2239 <a name="l2219"><span class="ln">2219 </span></a>        tuple, similar to ``{min, max}`` multipliers in regular expressions.  Tuples 
2240 <a name="l2220"><span class="ln">2220 </span></a>        may also include ``None`` as in: 
2241 <a name="l2221"><span class="ln">2221 </span></a>         - ``expr*(n, None)`` or ``expr*(n, )`` is equivalent 
2242 <a name="l2222"><span class="ln">2222 </span></a>              to ``expr*n + ZeroOrMore(expr)`` 
2243 <a name="l2223"><span class="ln">2223 </span></a>              (read as &quot;at least n instances of ``expr``&quot;) 
2244 <a name="l2224"><span class="ln">2224 </span></a>         - ``expr*(None, n)`` is equivalent to ``expr*(0, n)`` 
2245 <a name="l2225"><span class="ln">2225 </span></a>              (read as &quot;0 to n instances of ``expr``&quot;) 
2246 <a name="l2226"><span class="ln">2226 </span></a>         - ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)`` 
2247 <a name="l2227"><span class="ln">2227 </span></a>         - ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)`` 
2248 <a name="l2228"><span class="ln">2228 </span></a> 
2249 <a name="l2229"><span class="ln">2229 </span></a>        Note that ``expr*(None, n)`` does not raise an exception if 
2250 <a name="l2230"><span class="ln">2230 </span></a>        more than n exprs exist in the input stream; that is, 
2251 <a name="l2231"><span class="ln">2231 </span></a>        ``expr*(None, n)`` does not enforce a maximum number of expr 
2252 <a name="l2232"><span class="ln">2232 </span></a>        occurrences.  If this behavior is desired, then write 
2253 <a name="l2233"><span class="ln">2233 </span></a>        ``expr*(None, n) + ~expr`` 
2254 <a name="l2234"><span class="ln">2234 </span></a>        &quot;&quot;&quot;</span>
2255 <a name="l2235"><span class="ln">2235 </span></a>        <span class="s3">if </span><span class="s1">other </span><span class="s3">is </span><span class="s1">Ellipsis:</span>
2256 <a name="l2236"><span class="ln">2236 </span></a>            <span class="s1">other = (</span><span class="s4">0</span><span class="s3">, None</span><span class="s1">)</span>
2257 <a name="l2237"><span class="ln">2237 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">tuple) </span><span class="s3">and </span><span class="s1">other[:</span><span class="s4">1</span><span class="s1">] == (Ellipsis</span><span class="s3">,</span><span class="s1">):</span>
2258 <a name="l2238"><span class="ln">2238 </span></a>            <span class="s1">other = ((</span><span class="s4">0</span><span class="s3">, </span><span class="s1">) + other[</span><span class="s4">1</span><span class="s1">:] + (</span><span class="s3">None,</span><span class="s1">))[:</span><span class="s4">2</span><span class="s1">]</span>
2259 <a name="l2239"><span class="ln">2239 </span></a>
2260 <a name="l2240"><span class="ln">2240 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">int):</span>
2261 <a name="l2241"><span class="ln">2241 </span></a>            <span class="s1">minElements</span><span class="s3">, </span><span class="s1">optElements = other</span><span class="s3">, </span><span class="s4">0</span>
2262 <a name="l2242"><span class="ln">2242 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">tuple):</span>
2263 <a name="l2243"><span class="ln">2243 </span></a>            <span class="s1">other = tuple(o </span><span class="s3">if </span><span class="s1">o </span><span class="s3">is not </span><span class="s1">Ellipsis </span><span class="s3">else None for </span><span class="s1">o </span><span class="s3">in </span><span class="s1">other)</span>
2264 <a name="l2244"><span class="ln">2244 </span></a>            <span class="s1">other = (other + (</span><span class="s3">None, None</span><span class="s1">))[:</span><span class="s4">2</span><span class="s1">]</span>
2265 <a name="l2245"><span class="ln">2245 </span></a>            <span class="s3">if </span><span class="s1">other[</span><span class="s4">0</span><span class="s1">] </span><span class="s3">is None</span><span class="s1">:</span>
2266 <a name="l2246"><span class="ln">2246 </span></a>                <span class="s1">other = (</span><span class="s4">0</span><span class="s3">, </span><span class="s1">other[</span><span class="s4">1</span><span class="s1">])</span>
2267 <a name="l2247"><span class="ln">2247 </span></a>            <span class="s3">if </span><span class="s1">isinstance(other[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">int) </span><span class="s3">and </span><span class="s1">other[</span><span class="s4">1</span><span class="s1">] </span><span class="s3">is None</span><span class="s1">:</span>
2268 <a name="l2248"><span class="ln">2248 </span></a>                <span class="s3">if </span><span class="s1">other[</span><span class="s4">0</span><span class="s1">] == </span><span class="s4">0</span><span class="s1">:</span>
2269 <a name="l2249"><span class="ln">2249 </span></a>                    <span class="s3">return </span><span class="s1">ZeroOrMore(self)</span>
2270 <a name="l2250"><span class="ln">2250 </span></a>                <span class="s3">if </span><span class="s1">other[</span><span class="s4">0</span><span class="s1">] == </span><span class="s4">1</span><span class="s1">:</span>
2271 <a name="l2251"><span class="ln">2251 </span></a>                    <span class="s3">return </span><span class="s1">OneOrMore(self)</span>
2272 <a name="l2252"><span class="ln">2252 </span></a>                <span class="s3">else</span><span class="s1">:</span>
2273 <a name="l2253"><span class="ln">2253 </span></a>                    <span class="s3">return </span><span class="s1">self * other[</span><span class="s4">0</span><span class="s1">] + ZeroOrMore(self)</span>
2274 <a name="l2254"><span class="ln">2254 </span></a>            <span class="s3">elif </span><span class="s1">isinstance(other[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">int) </span><span class="s3">and </span><span class="s1">isinstance(other[</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">int):</span>
2275 <a name="l2255"><span class="ln">2255 </span></a>                <span class="s1">minElements</span><span class="s3">, </span><span class="s1">optElements = other</span>
2276 <a name="l2256"><span class="ln">2256 </span></a>                <span class="s1">optElements -= minElements</span>
2277 <a name="l2257"><span class="ln">2257 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2278 <a name="l2258"><span class="ln">2258 </span></a>                <span class="s3">raise </span><span class="s1">TypeError(</span><span class="s2">&quot;cannot multiply 'ParserElement' and ('%s', '%s') objects&quot;</span><span class="s3">, </span><span class="s1">type(other[</span><span class="s4">0</span><span class="s1">])</span><span class="s3">, </span><span class="s1">type(other[</span><span class="s4">1</span><span class="s1">]))</span>
2279 <a name="l2259"><span class="ln">2259 </span></a>        <span class="s3">else</span><span class="s1">:</span>
2280 <a name="l2260"><span class="ln">2260 </span></a>            <span class="s3">raise </span><span class="s1">TypeError(</span><span class="s2">&quot;cannot multiply 'ParserElement' and '%s' objects&quot;</span><span class="s3">, </span><span class="s1">type(other))</span>
2281 <a name="l2261"><span class="ln">2261 </span></a>
2282 <a name="l2262"><span class="ln">2262 </span></a>        <span class="s3">if </span><span class="s1">minElements &lt; </span><span class="s4">0</span><span class="s1">:</span>
2283 <a name="l2263"><span class="ln">2263 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;cannot multiply ParserElement by negative value&quot;</span><span class="s1">)</span>
2284 <a name="l2264"><span class="ln">2264 </span></a>        <span class="s3">if </span><span class="s1">optElements &lt; </span><span class="s4">0</span><span class="s1">:</span>
2285 <a name="l2265"><span class="ln">2265 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;second tuple value must be greater or equal to first tuple value&quot;</span><span class="s1">)</span>
2286 <a name="l2266"><span class="ln">2266 </span></a>        <span class="s3">if </span><span class="s1">minElements == optElements == </span><span class="s4">0</span><span class="s1">:</span>
2287 <a name="l2267"><span class="ln">2267 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;cannot multiply ParserElement by 0 or (0, 0)&quot;</span><span class="s1">)</span>
2288 <a name="l2268"><span class="ln">2268 </span></a>
2289 <a name="l2269"><span class="ln">2269 </span></a>        <span class="s3">if </span><span class="s1">optElements:</span>
2290 <a name="l2270"><span class="ln">2270 </span></a>            <span class="s3">def </span><span class="s1">makeOptionalList(n):</span>
2291 <a name="l2271"><span class="ln">2271 </span></a>                <span class="s3">if </span><span class="s1">n &gt; </span><span class="s4">1</span><span class="s1">:</span>
2292 <a name="l2272"><span class="ln">2272 </span></a>                    <span class="s3">return </span><span class="s1">Optional(self + makeOptionalList(n - </span><span class="s4">1</span><span class="s1">))</span>
2293 <a name="l2273"><span class="ln">2273 </span></a>                <span class="s3">else</span><span class="s1">:</span>
2294 <a name="l2274"><span class="ln">2274 </span></a>                    <span class="s3">return </span><span class="s1">Optional(self)</span>
2295 <a name="l2275"><span class="ln">2275 </span></a>            <span class="s3">if </span><span class="s1">minElements:</span>
2296 <a name="l2276"><span class="ln">2276 </span></a>                <span class="s3">if </span><span class="s1">minElements == </span><span class="s4">1</span><span class="s1">:</span>
2297 <a name="l2277"><span class="ln">2277 </span></a>                    <span class="s1">ret = self + makeOptionalList(optElements)</span>
2298 <a name="l2278"><span class="ln">2278 </span></a>                <span class="s3">else</span><span class="s1">:</span>
2299 <a name="l2279"><span class="ln">2279 </span></a>                    <span class="s1">ret = And([self] * minElements) + makeOptionalList(optElements)</span>
2300 <a name="l2280"><span class="ln">2280 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2301 <a name="l2281"><span class="ln">2281 </span></a>                <span class="s1">ret = makeOptionalList(optElements)</span>
2302 <a name="l2282"><span class="ln">2282 </span></a>        <span class="s3">else</span><span class="s1">:</span>
2303 <a name="l2283"><span class="ln">2283 </span></a>            <span class="s3">if </span><span class="s1">minElements == </span><span class="s4">1</span><span class="s1">:</span>
2304 <a name="l2284"><span class="ln">2284 </span></a>                <span class="s1">ret = self</span>
2305 <a name="l2285"><span class="ln">2285 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2306 <a name="l2286"><span class="ln">2286 </span></a>                <span class="s1">ret = And([self] * minElements)</span>
2307 <a name="l2287"><span class="ln">2287 </span></a>        <span class="s3">return </span><span class="s1">ret</span>
2308 <a name="l2288"><span class="ln">2288 </span></a>
2309 <a name="l2289"><span class="ln">2289 </span></a>    <span class="s3">def </span><span class="s1">__rmul__(self</span><span class="s3">, </span><span class="s1">other):</span>
2310 <a name="l2290"><span class="ln">2290 </span></a>        <span class="s3">return </span><span class="s1">self.__mul__(other)</span>
2311 <a name="l2291"><span class="ln">2291 </span></a>
2312 <a name="l2292"><span class="ln">2292 </span></a>    <span class="s3">def </span><span class="s1">__or__(self</span><span class="s3">, </span><span class="s1">other):</span>
2313 <a name="l2293"><span class="ln">2293 </span></a>        <span class="s5">&quot;&quot;&quot; 
2314 <a name="l2294"><span class="ln">2294 </span></a>        Implementation of | operator - returns :class:`MatchFirst` 
2315 <a name="l2295"><span class="ln">2295 </span></a>        &quot;&quot;&quot;</span>
2316 <a name="l2296"><span class="ln">2296 </span></a>        <span class="s3">if </span><span class="s1">other </span><span class="s3">is </span><span class="s1">Ellipsis:</span>
2317 <a name="l2297"><span class="ln">2297 </span></a>            <span class="s3">return </span><span class="s1">_PendingSkip(self</span><span class="s3">, </span><span class="s1">must_skip=</span><span class="s3">True</span><span class="s1">)</span>
2318 <a name="l2298"><span class="ln">2298 </span></a>
2319 <a name="l2299"><span class="ln">2299 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2320 <a name="l2300"><span class="ln">2300 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2321 <a name="l2301"><span class="ln">2301 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2322 <a name="l2302"><span class="ln">2302 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2323 <a name="l2303"><span class="ln">2303 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2324 <a name="l2304"><span class="ln">2304 </span></a>            <span class="s3">return None</span>
2325 <a name="l2305"><span class="ln">2305 </span></a>        <span class="s3">return </span><span class="s1">MatchFirst([self</span><span class="s3">, </span><span class="s1">other])</span>
2326 <a name="l2306"><span class="ln">2306 </span></a>
2327 <a name="l2307"><span class="ln">2307 </span></a>    <span class="s3">def </span><span class="s1">__ror__(self</span><span class="s3">, </span><span class="s1">other):</span>
2328 <a name="l2308"><span class="ln">2308 </span></a>        <span class="s5">&quot;&quot;&quot; 
2329 <a name="l2309"><span class="ln">2309 </span></a>        Implementation of | operator when left operand is not a :class:`ParserElement` 
2330 <a name="l2310"><span class="ln">2310 </span></a>        &quot;&quot;&quot;</span>
2331 <a name="l2311"><span class="ln">2311 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2332 <a name="l2312"><span class="ln">2312 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2333 <a name="l2313"><span class="ln">2313 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2334 <a name="l2314"><span class="ln">2314 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2335 <a name="l2315"><span class="ln">2315 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2336 <a name="l2316"><span class="ln">2316 </span></a>            <span class="s3">return None</span>
2337 <a name="l2317"><span class="ln">2317 </span></a>        <span class="s3">return </span><span class="s1">other | self</span>
2338 <a name="l2318"><span class="ln">2318 </span></a>
2339 <a name="l2319"><span class="ln">2319 </span></a>    <span class="s3">def </span><span class="s1">__xor__(self</span><span class="s3">, </span><span class="s1">other):</span>
2340 <a name="l2320"><span class="ln">2320 </span></a>        <span class="s5">&quot;&quot;&quot; 
2341 <a name="l2321"><span class="ln">2321 </span></a>        Implementation of ^ operator - returns :class:`Or` 
2342 <a name="l2322"><span class="ln">2322 </span></a>        &quot;&quot;&quot;</span>
2343 <a name="l2323"><span class="ln">2323 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2344 <a name="l2324"><span class="ln">2324 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2345 <a name="l2325"><span class="ln">2325 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2346 <a name="l2326"><span class="ln">2326 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2347 <a name="l2327"><span class="ln">2327 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2348 <a name="l2328"><span class="ln">2328 </span></a>            <span class="s3">return None</span>
2349 <a name="l2329"><span class="ln">2329 </span></a>        <span class="s3">return </span><span class="s1">Or([self</span><span class="s3">, </span><span class="s1">other])</span>
2350 <a name="l2330"><span class="ln">2330 </span></a>
2351 <a name="l2331"><span class="ln">2331 </span></a>    <span class="s3">def </span><span class="s1">__rxor__(self</span><span class="s3">, </span><span class="s1">other):</span>
2352 <a name="l2332"><span class="ln">2332 </span></a>        <span class="s5">&quot;&quot;&quot; 
2353 <a name="l2333"><span class="ln">2333 </span></a>        Implementation of ^ operator when left operand is not a :class:`ParserElement` 
2354 <a name="l2334"><span class="ln">2334 </span></a>        &quot;&quot;&quot;</span>
2355 <a name="l2335"><span class="ln">2335 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2356 <a name="l2336"><span class="ln">2336 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2357 <a name="l2337"><span class="ln">2337 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2358 <a name="l2338"><span class="ln">2338 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2359 <a name="l2339"><span class="ln">2339 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2360 <a name="l2340"><span class="ln">2340 </span></a>            <span class="s3">return None</span>
2361 <a name="l2341"><span class="ln">2341 </span></a>        <span class="s3">return </span><span class="s1">other ^ self</span>
2362 <a name="l2342"><span class="ln">2342 </span></a>
2363 <a name="l2343"><span class="ln">2343 </span></a>    <span class="s3">def </span><span class="s1">__and__(self</span><span class="s3">, </span><span class="s1">other):</span>
2364 <a name="l2344"><span class="ln">2344 </span></a>        <span class="s5">&quot;&quot;&quot; 
2365 <a name="l2345"><span class="ln">2345 </span></a>        Implementation of &amp; operator - returns :class:`Each` 
2366 <a name="l2346"><span class="ln">2346 </span></a>        &quot;&quot;&quot;</span>
2367 <a name="l2347"><span class="ln">2347 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2368 <a name="l2348"><span class="ln">2348 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2369 <a name="l2349"><span class="ln">2349 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2370 <a name="l2350"><span class="ln">2350 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2371 <a name="l2351"><span class="ln">2351 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2372 <a name="l2352"><span class="ln">2352 </span></a>            <span class="s3">return None</span>
2373 <a name="l2353"><span class="ln">2353 </span></a>        <span class="s3">return </span><span class="s1">Each([self</span><span class="s3">, </span><span class="s1">other])</span>
2374 <a name="l2354"><span class="ln">2354 </span></a>
2375 <a name="l2355"><span class="ln">2355 </span></a>    <span class="s3">def </span><span class="s1">__rand__(self</span><span class="s3">, </span><span class="s1">other):</span>
2376 <a name="l2356"><span class="ln">2356 </span></a>        <span class="s5">&quot;&quot;&quot; 
2377 <a name="l2357"><span class="ln">2357 </span></a>        Implementation of &amp; operator when left operand is not a :class:`ParserElement` 
2378 <a name="l2358"><span class="ln">2358 </span></a>        &quot;&quot;&quot;</span>
2379 <a name="l2359"><span class="ln">2359 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2380 <a name="l2360"><span class="ln">2360 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
2381 <a name="l2361"><span class="ln">2361 </span></a>        <span class="s3">if not </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2382 <a name="l2362"><span class="ln">2362 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Cannot combine element of type %s with ParserElement&quot; </span><span class="s1">% type(other)</span><span class="s3">,</span>
2383 <a name="l2363"><span class="ln">2363 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2384 <a name="l2364"><span class="ln">2364 </span></a>            <span class="s3">return None</span>
2385 <a name="l2365"><span class="ln">2365 </span></a>        <span class="s3">return </span><span class="s1">other &amp; self</span>
2386 <a name="l2366"><span class="ln">2366 </span></a>
2387 <a name="l2367"><span class="ln">2367 </span></a>    <span class="s3">def </span><span class="s1">__invert__(self):</span>
2388 <a name="l2368"><span class="ln">2368 </span></a>        <span class="s5">&quot;&quot;&quot; 
2389 <a name="l2369"><span class="ln">2369 </span></a>        Implementation of ~ operator - returns :class:`NotAny` 
2390 <a name="l2370"><span class="ln">2370 </span></a>        &quot;&quot;&quot;</span>
2391 <a name="l2371"><span class="ln">2371 </span></a>        <span class="s3">return </span><span class="s1">NotAny(self)</span>
2392 <a name="l2372"><span class="ln">2372 </span></a>
2393 <a name="l2373"><span class="ln">2373 </span></a>    <span class="s3">def </span><span class="s1">__iter__(self):</span>
2394 <a name="l2374"><span class="ln">2374 </span></a>        <span class="s0"># must implement __iter__ to override legacy use of sequential access to __getitem__ to</span>
2395 <a name="l2375"><span class="ln">2375 </span></a>        <span class="s0"># iterate over a sequence</span>
2396 <a name="l2376"><span class="ln">2376 </span></a>        <span class="s3">raise </span><span class="s1">TypeError(</span><span class="s2">'%r object is not iterable' </span><span class="s1">% self.__class__.__name__)</span>
2397 <a name="l2377"><span class="ln">2377 </span></a>
2398 <a name="l2378"><span class="ln">2378 </span></a>    <span class="s3">def </span><span class="s1">__getitem__(self</span><span class="s3">, </span><span class="s1">key):</span>
2399 <a name="l2379"><span class="ln">2379 </span></a>        <span class="s5">&quot;&quot;&quot; 
2400 <a name="l2380"><span class="ln">2380 </span></a>        use ``[]`` indexing notation as a short form for expression repetition: 
2401 <a name="l2381"><span class="ln">2381 </span></a>         - ``expr[n]`` is equivalent to ``expr*n`` 
2402 <a name="l2382"><span class="ln">2382 </span></a>         - ``expr[m, n]`` is equivalent to ``expr*(m, n)`` 
2403 <a name="l2383"><span class="ln">2383 </span></a>         - ``expr[n, ...]`` or ``expr[n,]`` is equivalent 
2404 <a name="l2384"><span class="ln">2384 </span></a>              to ``expr*n + ZeroOrMore(expr)`` 
2405 <a name="l2385"><span class="ln">2385 </span></a>              (read as &quot;at least n instances of ``expr``&quot;) 
2406 <a name="l2386"><span class="ln">2386 </span></a>         - ``expr[..., n]`` is equivalent to ``expr*(0, n)`` 
2407 <a name="l2387"><span class="ln">2387 </span></a>              (read as &quot;0 to n instances of ``expr``&quot;) 
2408 <a name="l2388"><span class="ln">2388 </span></a>         - ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)`` 
2409 <a name="l2389"><span class="ln">2389 </span></a>         - ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)`` 
2410 <a name="l2390"><span class="ln">2390 </span></a>         ``None`` may be used in place of ``...``. 
2411 <a name="l2391"><span class="ln">2391 </span></a> 
2412 <a name="l2392"><span class="ln">2392 </span></a>        Note that ``expr[..., n]`` and ``expr[m, n]``do not raise an exception 
2413 <a name="l2393"><span class="ln">2393 </span></a>        if more than ``n`` ``expr``s exist in the input stream.  If this behavior is 
2414 <a name="l2394"><span class="ln">2394 </span></a>        desired, then write ``expr[..., n] + ~expr``. 
2415 <a name="l2395"><span class="ln">2395 </span></a>       &quot;&quot;&quot;</span>
2416 <a name="l2396"><span class="ln">2396 </span></a>
2417 <a name="l2397"><span class="ln">2397 </span></a>        <span class="s0"># convert single arg keys to tuples</span>
2418 <a name="l2398"><span class="ln">2398 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2419 <a name="l2399"><span class="ln">2399 </span></a>            <span class="s3">if </span><span class="s1">isinstance(key</span><span class="s3">, </span><span class="s1">str):</span>
2420 <a name="l2400"><span class="ln">2400 </span></a>                <span class="s1">key = (key</span><span class="s3">,</span><span class="s1">)</span>
2421 <a name="l2401"><span class="ln">2401 </span></a>            <span class="s1">iter(key)</span>
2422 <a name="l2402"><span class="ln">2402 </span></a>        <span class="s3">except </span><span class="s1">TypeError:</span>
2423 <a name="l2403"><span class="ln">2403 </span></a>            <span class="s1">key = (key</span><span class="s3">, </span><span class="s1">key)</span>
2424 <a name="l2404"><span class="ln">2404 </span></a>
2425 <a name="l2405"><span class="ln">2405 </span></a>        <span class="s3">if </span><span class="s1">len(key) &gt; </span><span class="s4">2</span><span class="s1">:</span>
2426 <a name="l2406"><span class="ln">2406 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;only 1 or 2 index arguments supported ({0}{1})&quot;</span><span class="s1">.format(key[:</span><span class="s4">5</span><span class="s1">]</span><span class="s3">,</span>
2427 <a name="l2407"><span class="ln">2407 </span></a>                                                                                <span class="s2">'... [{0}]'</span><span class="s1">.format(len(key))</span>
2428 <a name="l2408"><span class="ln">2408 </span></a>                                                                                <span class="s3">if </span><span class="s1">len(key) &gt; </span><span class="s4">5 </span><span class="s3">else </span><span class="s2">''</span><span class="s1">))</span>
2429 <a name="l2409"><span class="ln">2409 </span></a>
2430 <a name="l2410"><span class="ln">2410 </span></a>        <span class="s0"># clip to 2 elements</span>
2431 <a name="l2411"><span class="ln">2411 </span></a>        <span class="s1">ret = self * tuple(key[:</span><span class="s4">2</span><span class="s1">])</span>
2432 <a name="l2412"><span class="ln">2412 </span></a>        <span class="s3">return </span><span class="s1">ret</span>
2433 <a name="l2413"><span class="ln">2413 </span></a>
2434 <a name="l2414"><span class="ln">2414 </span></a>    <span class="s3">def </span><span class="s1">__call__(self</span><span class="s3">, </span><span class="s1">name=</span><span class="s3">None</span><span class="s1">):</span>
2435 <a name="l2415"><span class="ln">2415 </span></a>        <span class="s5">&quot;&quot;&quot; 
2436 <a name="l2416"><span class="ln">2416 </span></a>        Shortcut for :class:`setResultsName`, with ``listAllMatches=False``. 
2437 <a name="l2417"><span class="ln">2417 </span></a> 
2438 <a name="l2418"><span class="ln">2418 </span></a>        If ``name`` is given with a trailing ``'*'`` character, then ``listAllMatches`` will be 
2439 <a name="l2419"><span class="ln">2419 </span></a>        passed as ``True``. 
2440 <a name="l2420"><span class="ln">2420 </span></a> 
2441 <a name="l2421"><span class="ln">2421 </span></a>        If ``name` is omitted, same as calling :class:`copy`. 
2442 <a name="l2422"><span class="ln">2422 </span></a> 
2443 <a name="l2423"><span class="ln">2423 </span></a>        Example:: 
2444 <a name="l2424"><span class="ln">2424 </span></a> 
2445 <a name="l2425"><span class="ln">2425 </span></a>            # these are equivalent 
2446 <a name="l2426"><span class="ln">2426 </span></a>            userdata = Word(alphas).setResultsName(&quot;name&quot;) + Word(nums + &quot;-&quot;).setResultsName(&quot;socsecno&quot;) 
2447 <a name="l2427"><span class="ln">2427 </span></a>            userdata = Word(alphas)(&quot;name&quot;) + Word(nums + &quot;-&quot;)(&quot;socsecno&quot;) 
2448 <a name="l2428"><span class="ln">2428 </span></a>        &quot;&quot;&quot;</span>
2449 <a name="l2429"><span class="ln">2429 </span></a>        <span class="s3">if </span><span class="s1">name </span><span class="s3">is not None</span><span class="s1">:</span>
2450 <a name="l2430"><span class="ln">2430 </span></a>            <span class="s3">return </span><span class="s1">self._setResultsName(name)</span>
2451 <a name="l2431"><span class="ln">2431 </span></a>        <span class="s3">else</span><span class="s1">:</span>
2452 <a name="l2432"><span class="ln">2432 </span></a>            <span class="s3">return </span><span class="s1">self.copy()</span>
2453 <a name="l2433"><span class="ln">2433 </span></a>
2454 <a name="l2434"><span class="ln">2434 </span></a>    <span class="s3">def </span><span class="s1">suppress(self):</span>
2455 <a name="l2435"><span class="ln">2435 </span></a>        <span class="s5">&quot;&quot;&quot; 
2456 <a name="l2436"><span class="ln">2436 </span></a>        Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from 
2457 <a name="l2437"><span class="ln">2437 </span></a>        cluttering up returned output. 
2458 <a name="l2438"><span class="ln">2438 </span></a>        &quot;&quot;&quot;</span>
2459 <a name="l2439"><span class="ln">2439 </span></a>        <span class="s3">return </span><span class="s1">Suppress(self)</span>
2460 <a name="l2440"><span class="ln">2440 </span></a>
2461 <a name="l2441"><span class="ln">2441 </span></a>    <span class="s3">def </span><span class="s1">leaveWhitespace(self):</span>
2462 <a name="l2442"><span class="ln">2442 </span></a>        <span class="s5">&quot;&quot;&quot; 
2463 <a name="l2443"><span class="ln">2443 </span></a>        Disables the skipping of whitespace before matching the characters in the 
2464 <a name="l2444"><span class="ln">2444 </span></a>        :class:`ParserElement`'s defined pattern.  This is normally only used internally by 
2465 <a name="l2445"><span class="ln">2445 </span></a>        the pyparsing module, but may be needed in some whitespace-sensitive grammars. 
2466 <a name="l2446"><span class="ln">2446 </span></a>        &quot;&quot;&quot;</span>
2467 <a name="l2447"><span class="ln">2447 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
2468 <a name="l2448"><span class="ln">2448 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2469 <a name="l2449"><span class="ln">2449 </span></a>
2470 <a name="l2450"><span class="ln">2450 </span></a>    <span class="s3">def </span><span class="s1">setWhitespaceChars(self</span><span class="s3">, </span><span class="s1">chars):</span>
2471 <a name="l2451"><span class="ln">2451 </span></a>        <span class="s5">&quot;&quot;&quot; 
2472 <a name="l2452"><span class="ln">2452 </span></a>        Overrides the default whitespace chars 
2473 <a name="l2453"><span class="ln">2453 </span></a>        &quot;&quot;&quot;</span>
2474 <a name="l2454"><span class="ln">2454 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">True</span>
2475 <a name="l2455"><span class="ln">2455 </span></a>        <span class="s1">self.whiteChars = chars</span>
2476 <a name="l2456"><span class="ln">2456 </span></a>        <span class="s1">self.copyDefaultWhiteChars = </span><span class="s3">False</span>
2477 <a name="l2457"><span class="ln">2457 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2478 <a name="l2458"><span class="ln">2458 </span></a>
2479 <a name="l2459"><span class="ln">2459 </span></a>    <span class="s3">def </span><span class="s1">parseWithTabs(self):</span>
2480 <a name="l2460"><span class="ln">2460 </span></a>        <span class="s5">&quot;&quot;&quot; 
2481 <a name="l2461"><span class="ln">2461 </span></a>        Overrides default behavior to expand ``&lt;TAB&gt;``s to spaces before parsing the input string. 
2482 <a name="l2462"><span class="ln">2462 </span></a>        Must be called before ``parseString`` when the input grammar contains elements that 
2483 <a name="l2463"><span class="ln">2463 </span></a>        match ``&lt;TAB&gt;`` characters. 
2484 <a name="l2464"><span class="ln">2464 </span></a>        &quot;&quot;&quot;</span>
2485 <a name="l2465"><span class="ln">2465 </span></a>        <span class="s1">self.keepTabs = </span><span class="s3">True</span>
2486 <a name="l2466"><span class="ln">2466 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2487 <a name="l2467"><span class="ln">2467 </span></a>
2488 <a name="l2468"><span class="ln">2468 </span></a>    <span class="s3">def </span><span class="s1">ignore(self</span><span class="s3">, </span><span class="s1">other):</span>
2489 <a name="l2469"><span class="ln">2469 </span></a>        <span class="s5">&quot;&quot;&quot; 
2490 <a name="l2470"><span class="ln">2470 </span></a>        Define expression to be ignored (e.g., comments) while doing pattern 
2491 <a name="l2471"><span class="ln">2471 </span></a>        matching; may be called repeatedly, to define multiple comment or other 
2492 <a name="l2472"><span class="ln">2472 </span></a>        ignorable patterns. 
2493 <a name="l2473"><span class="ln">2473 </span></a> 
2494 <a name="l2474"><span class="ln">2474 </span></a>        Example:: 
2495 <a name="l2475"><span class="ln">2475 </span></a> 
2496 <a name="l2476"><span class="ln">2476 </span></a>            patt = OneOrMore(Word(alphas)) 
2497 <a name="l2477"><span class="ln">2477 </span></a>            patt.parseString('ablaj /* comment */ lskjd') # -&gt; ['ablaj'] 
2498 <a name="l2478"><span class="ln">2478 </span></a> 
2499 <a name="l2479"><span class="ln">2479 </span></a>            patt.ignore(cStyleComment) 
2500 <a name="l2480"><span class="ln">2480 </span></a>            patt.parseString('ablaj /* comment */ lskjd') # -&gt; ['ablaj', 'lskjd'] 
2501 <a name="l2481"><span class="ln">2481 </span></a>        &quot;&quot;&quot;</span>
2502 <a name="l2482"><span class="ln">2482 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2503 <a name="l2483"><span class="ln">2483 </span></a>            <span class="s1">other = Suppress(other)</span>
2504 <a name="l2484"><span class="ln">2484 </span></a>
2505 <a name="l2485"><span class="ln">2485 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">Suppress):</span>
2506 <a name="l2486"><span class="ln">2486 </span></a>            <span class="s3">if </span><span class="s1">other </span><span class="s3">not in </span><span class="s1">self.ignoreExprs:</span>
2507 <a name="l2487"><span class="ln">2487 </span></a>                <span class="s1">self.ignoreExprs.append(other)</span>
2508 <a name="l2488"><span class="ln">2488 </span></a>        <span class="s3">else</span><span class="s1">:</span>
2509 <a name="l2489"><span class="ln">2489 </span></a>            <span class="s1">self.ignoreExprs.append(Suppress(other.copy()))</span>
2510 <a name="l2490"><span class="ln">2490 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2511 <a name="l2491"><span class="ln">2491 </span></a>
2512 <a name="l2492"><span class="ln">2492 </span></a>    <span class="s3">def </span><span class="s1">setDebugActions(self</span><span class="s3">, </span><span class="s1">startAction</span><span class="s3">, </span><span class="s1">successAction</span><span class="s3">, </span><span class="s1">exceptionAction):</span>
2513 <a name="l2493"><span class="ln">2493 </span></a>        <span class="s5">&quot;&quot;&quot; 
2514 <a name="l2494"><span class="ln">2494 </span></a>        Enable display of debugging messages while doing pattern matching. 
2515 <a name="l2495"><span class="ln">2495 </span></a>        &quot;&quot;&quot;</span>
2516 <a name="l2496"><span class="ln">2496 </span></a>        <span class="s1">self.debugActions = (startAction </span><span class="s3">or </span><span class="s1">_defaultStartDebugAction</span><span class="s3">,</span>
2517 <a name="l2497"><span class="ln">2497 </span></a>                             <span class="s1">successAction </span><span class="s3">or </span><span class="s1">_defaultSuccessDebugAction</span><span class="s3">,</span>
2518 <a name="l2498"><span class="ln">2498 </span></a>                             <span class="s1">exceptionAction </span><span class="s3">or </span><span class="s1">_defaultExceptionDebugAction)</span>
2519 <a name="l2499"><span class="ln">2499 </span></a>        <span class="s1">self.debug = </span><span class="s3">True</span>
2520 <a name="l2500"><span class="ln">2500 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2521 <a name="l2501"><span class="ln">2501 </span></a>
2522 <a name="l2502"><span class="ln">2502 </span></a>    <span class="s3">def </span><span class="s1">setDebug(self</span><span class="s3">, </span><span class="s1">flag=</span><span class="s3">True</span><span class="s1">):</span>
2523 <a name="l2503"><span class="ln">2503 </span></a>        <span class="s5">&quot;&quot;&quot; 
2524 <a name="l2504"><span class="ln">2504 </span></a>        Enable display of debugging messages while doing pattern matching. 
2525 <a name="l2505"><span class="ln">2505 </span></a>        Set ``flag`` to True to enable, False to disable. 
2526 <a name="l2506"><span class="ln">2506 </span></a> 
2527 <a name="l2507"><span class="ln">2507 </span></a>        Example:: 
2528 <a name="l2508"><span class="ln">2508 </span></a> 
2529 <a name="l2509"><span class="ln">2509 </span></a>            wd = Word(alphas).setName(&quot;alphaword&quot;) 
2530 <a name="l2510"><span class="ln">2510 </span></a>            integer = Word(nums).setName(&quot;numword&quot;) 
2531 <a name="l2511"><span class="ln">2511 </span></a>            term = wd | integer 
2532 <a name="l2512"><span class="ln">2512 </span></a> 
2533 <a name="l2513"><span class="ln">2513 </span></a>            # turn on debugging for wd 
2534 <a name="l2514"><span class="ln">2514 </span></a>            wd.setDebug() 
2535 <a name="l2515"><span class="ln">2515 </span></a> 
2536 <a name="l2516"><span class="ln">2516 </span></a>            OneOrMore(term).parseString(&quot;abc 123 xyz 890&quot;) 
2537 <a name="l2517"><span class="ln">2517 </span></a> 
2538 <a name="l2518"><span class="ln">2518 </span></a>        prints:: 
2539 <a name="l2519"><span class="ln">2519 </span></a> 
2540 <a name="l2520"><span class="ln">2520 </span></a>            Match alphaword at loc 0(1,1) 
2541 <a name="l2521"><span class="ln">2521 </span></a>            Matched alphaword -&gt; ['abc'] 
2542 <a name="l2522"><span class="ln">2522 </span></a>            Match alphaword at loc 3(1,4) 
2543 <a name="l2523"><span class="ln">2523 </span></a>            Exception raised:Expected alphaword (at char 4), (line:1, col:5) 
2544 <a name="l2524"><span class="ln">2524 </span></a>            Match alphaword at loc 7(1,8) 
2545 <a name="l2525"><span class="ln">2525 </span></a>            Matched alphaword -&gt; ['xyz'] 
2546 <a name="l2526"><span class="ln">2526 </span></a>            Match alphaword at loc 11(1,12) 
2547 <a name="l2527"><span class="ln">2527 </span></a>            Exception raised:Expected alphaword (at char 12), (line:1, col:13) 
2548 <a name="l2528"><span class="ln">2528 </span></a>            Match alphaword at loc 15(1,16) 
2549 <a name="l2529"><span class="ln">2529 </span></a>            Exception raised:Expected alphaword (at char 15), (line:1, col:16) 
2550 <a name="l2530"><span class="ln">2530 </span></a> 
2551 <a name="l2531"><span class="ln">2531 </span></a>        The output shown is that produced by the default debug actions - custom debug actions can be 
2552 <a name="l2532"><span class="ln">2532 </span></a>        specified using :class:`setDebugActions`. Prior to attempting 
2553 <a name="l2533"><span class="ln">2533 </span></a>        to match the ``wd`` expression, the debugging message ``&quot;Match &lt;exprname&gt; at loc &lt;n&gt;(&lt;line&gt;,&lt;col&gt;)&quot;`` 
2554 <a name="l2534"><span class="ln">2534 </span></a>        is shown. Then if the parse succeeds, a ``&quot;Matched&quot;`` message is shown, or an ``&quot;Exception raised&quot;`` 
2555 <a name="l2535"><span class="ln">2535 </span></a>        message is shown. Also note the use of :class:`setName` to assign a human-readable name to the expression, 
2556 <a name="l2536"><span class="ln">2536 </span></a>        which makes debugging and exception messages easier to understand - for instance, the default 
2557 <a name="l2537"><span class="ln">2537 </span></a>        name created for the :class:`Word` expression without calling ``setName`` is ``&quot;W:(ABCD...)&quot;``. 
2558 <a name="l2538"><span class="ln">2538 </span></a>        &quot;&quot;&quot;</span>
2559 <a name="l2539"><span class="ln">2539 </span></a>        <span class="s3">if </span><span class="s1">flag:</span>
2560 <a name="l2540"><span class="ln">2540 </span></a>            <span class="s1">self.setDebugActions(_defaultStartDebugAction</span><span class="s3">, </span><span class="s1">_defaultSuccessDebugAction</span><span class="s3">, </span><span class="s1">_defaultExceptionDebugAction)</span>
2561 <a name="l2541"><span class="ln">2541 </span></a>        <span class="s3">else</span><span class="s1">:</span>
2562 <a name="l2542"><span class="ln">2542 </span></a>            <span class="s1">self.debug = </span><span class="s3">False</span>
2563 <a name="l2543"><span class="ln">2543 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2564 <a name="l2544"><span class="ln">2544 </span></a>
2565 <a name="l2545"><span class="ln">2545 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
2566 <a name="l2546"><span class="ln">2546 </span></a>        <span class="s3">return </span><span class="s1">self.name</span>
2567 <a name="l2547"><span class="ln">2547 </span></a>
2568 <a name="l2548"><span class="ln">2548 </span></a>    <span class="s3">def </span><span class="s1">__repr__(self):</span>
2569 <a name="l2549"><span class="ln">2549 </span></a>        <span class="s3">return </span><span class="s1">_ustr(self)</span>
2570 <a name="l2550"><span class="ln">2550 </span></a>
2571 <a name="l2551"><span class="ln">2551 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
2572 <a name="l2552"><span class="ln">2552 </span></a>        <span class="s1">self.streamlined = </span><span class="s3">True</span>
2573 <a name="l2553"><span class="ln">2553 </span></a>        <span class="s1">self.strRepr = </span><span class="s3">None</span>
2574 <a name="l2554"><span class="ln">2554 </span></a>        <span class="s3">return </span><span class="s1">self</span>
2575 <a name="l2555"><span class="ln">2555 </span></a>
2576 <a name="l2556"><span class="ln">2556 </span></a>    <span class="s3">def </span><span class="s1">checkRecursion(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
2577 <a name="l2557"><span class="ln">2557 </span></a>        <span class="s3">pass</span>
2578 <a name="l2558"><span class="ln">2558 </span></a>
2579 <a name="l2559"><span class="ln">2559 </span></a>    <span class="s3">def </span><span class="s1">validate(self</span><span class="s3">, </span><span class="s1">validateTrace=</span><span class="s3">None</span><span class="s1">):</span>
2580 <a name="l2560"><span class="ln">2560 </span></a>        <span class="s5">&quot;&quot;&quot; 
2581 <a name="l2561"><span class="ln">2561 </span></a>        Check defined expressions for valid structure, check for infinite recursive definitions. 
2582 <a name="l2562"><span class="ln">2562 </span></a>        &quot;&quot;&quot;</span>
2583 <a name="l2563"><span class="ln">2563 </span></a>        <span class="s1">self.checkRecursion([])</span>
2584 <a name="l2564"><span class="ln">2564 </span></a>
2585 <a name="l2565"><span class="ln">2565 </span></a>    <span class="s3">def </span><span class="s1">parseFile(self</span><span class="s3">, </span><span class="s1">file_or_filename</span><span class="s3">, </span><span class="s1">parseAll=</span><span class="s3">False</span><span class="s1">):</span>
2586 <a name="l2566"><span class="ln">2566 </span></a>        <span class="s5">&quot;&quot;&quot; 
2587 <a name="l2567"><span class="ln">2567 </span></a>        Execute the parse expression on the given file or filename. 
2588 <a name="l2568"><span class="ln">2568 </span></a>        If a filename is specified (instead of a file object), 
2589 <a name="l2569"><span class="ln">2569 </span></a>        the entire file is opened, read, and closed before parsing. 
2590 <a name="l2570"><span class="ln">2570 </span></a>        &quot;&quot;&quot;</span>
2591 <a name="l2571"><span class="ln">2571 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2592 <a name="l2572"><span class="ln">2572 </span></a>            <span class="s1">file_contents = file_or_filename.read()</span>
2593 <a name="l2573"><span class="ln">2573 </span></a>        <span class="s3">except </span><span class="s1">AttributeError:</span>
2594 <a name="l2574"><span class="ln">2574 </span></a>            <span class="s3">with </span><span class="s1">open(file_or_filename</span><span class="s3">, </span><span class="s2">&quot;r&quot;</span><span class="s1">) </span><span class="s3">as </span><span class="s1">f:</span>
2595 <a name="l2575"><span class="ln">2575 </span></a>                <span class="s1">file_contents = f.read()</span>
2596 <a name="l2576"><span class="ln">2576 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2597 <a name="l2577"><span class="ln">2577 </span></a>            <span class="s3">return </span><span class="s1">self.parseString(file_contents</span><span class="s3">, </span><span class="s1">parseAll)</span>
2598 <a name="l2578"><span class="ln">2578 </span></a>        <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">exc:</span>
2599 <a name="l2579"><span class="ln">2579 </span></a>            <span class="s3">if </span><span class="s1">ParserElement.verbose_stacktrace:</span>
2600 <a name="l2580"><span class="ln">2580 </span></a>                <span class="s3">raise</span>
2601 <a name="l2581"><span class="ln">2581 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2602 <a name="l2582"><span class="ln">2582 </span></a>                <span class="s0"># catch and re-raise exception from here, clearing out pyparsing internal stack trace</span>
2603 <a name="l2583"><span class="ln">2583 </span></a>                <span class="s3">if </span><span class="s1">getattr(exc</span><span class="s3">, </span><span class="s2">'__traceback__'</span><span class="s3">, None</span><span class="s1">) </span><span class="s3">is not None</span><span class="s1">:</span>
2604 <a name="l2584"><span class="ln">2584 </span></a>                    <span class="s1">exc.__traceback__ = self._trim_traceback(exc.__traceback__)</span>
2605 <a name="l2585"><span class="ln">2585 </span></a>                <span class="s3">raise </span><span class="s1">exc</span>
2606 <a name="l2586"><span class="ln">2586 </span></a>
2607 <a name="l2587"><span class="ln">2587 </span></a>    <span class="s3">def </span><span class="s1">__eq__(self</span><span class="s3">, </span><span class="s1">other):</span>
2608 <a name="l2588"><span class="ln">2588 </span></a>        <span class="s3">if </span><span class="s1">self </span><span class="s3">is </span><span class="s1">other:</span>
2609 <a name="l2589"><span class="ln">2589 </span></a>            <span class="s3">return True</span>
2610 <a name="l2590"><span class="ln">2590 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
2611 <a name="l2591"><span class="ln">2591 </span></a>            <span class="s3">return </span><span class="s1">self.matches(other)</span>
2612 <a name="l2592"><span class="ln">2592 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">ParserElement):</span>
2613 <a name="l2593"><span class="ln">2593 </span></a>            <span class="s3">return </span><span class="s1">vars(self) == vars(other)</span>
2614 <a name="l2594"><span class="ln">2594 </span></a>        <span class="s3">return False</span>
2615 <a name="l2595"><span class="ln">2595 </span></a>
2616 <a name="l2596"><span class="ln">2596 </span></a>    <span class="s3">def </span><span class="s1">__ne__(self</span><span class="s3">, </span><span class="s1">other):</span>
2617 <a name="l2597"><span class="ln">2597 </span></a>        <span class="s3">return not </span><span class="s1">(self == other)</span>
2618 <a name="l2598"><span class="ln">2598 </span></a>
2619 <a name="l2599"><span class="ln">2599 </span></a>    <span class="s3">def </span><span class="s1">__hash__(self):</span>
2620 <a name="l2600"><span class="ln">2600 </span></a>        <span class="s3">return </span><span class="s1">id(self)</span>
2621 <a name="l2601"><span class="ln">2601 </span></a>
2622 <a name="l2602"><span class="ln">2602 </span></a>    <span class="s3">def </span><span class="s1">__req__(self</span><span class="s3">, </span><span class="s1">other):</span>
2623 <a name="l2603"><span class="ln">2603 </span></a>        <span class="s3">return </span><span class="s1">self == other</span>
2624 <a name="l2604"><span class="ln">2604 </span></a>
2625 <a name="l2605"><span class="ln">2605 </span></a>    <span class="s3">def </span><span class="s1">__rne__(self</span><span class="s3">, </span><span class="s1">other):</span>
2626 <a name="l2606"><span class="ln">2606 </span></a>        <span class="s3">return not </span><span class="s1">(self == other)</span>
2627 <a name="l2607"><span class="ln">2607 </span></a>
2628 <a name="l2608"><span class="ln">2608 </span></a>    <span class="s3">def </span><span class="s1">matches(self</span><span class="s3">, </span><span class="s1">testString</span><span class="s3">, </span><span class="s1">parseAll=</span><span class="s3">True</span><span class="s1">):</span>
2629 <a name="l2609"><span class="ln">2609 </span></a>        <span class="s5">&quot;&quot;&quot; 
2630 <a name="l2610"><span class="ln">2610 </span></a>        Method for quick testing of a parser against a test string. Good for simple 
2631 <a name="l2611"><span class="ln">2611 </span></a>        inline microtests of sub expressions while building up larger parser. 
2632 <a name="l2612"><span class="ln">2612 </span></a> 
2633 <a name="l2613"><span class="ln">2613 </span></a>        Parameters: 
2634 <a name="l2614"><span class="ln">2614 </span></a>         - testString - to test against this expression for a match 
2635 <a name="l2615"><span class="ln">2615 </span></a>         - parseAll - (default= ``True``) - flag to pass to :class:`parseString` when running tests 
2636 <a name="l2616"><span class="ln">2616 </span></a> 
2637 <a name="l2617"><span class="ln">2617 </span></a>        Example:: 
2638 <a name="l2618"><span class="ln">2618 </span></a> 
2639 <a name="l2619"><span class="ln">2619 </span></a>            expr = Word(nums) 
2640 <a name="l2620"><span class="ln">2620 </span></a>            assert expr.matches(&quot;100&quot;) 
2641 <a name="l2621"><span class="ln">2621 </span></a>        &quot;&quot;&quot;</span>
2642 <a name="l2622"><span class="ln">2622 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2643 <a name="l2623"><span class="ln">2623 </span></a>            <span class="s1">self.parseString(_ustr(testString)</span><span class="s3">, </span><span class="s1">parseAll=parseAll)</span>
2644 <a name="l2624"><span class="ln">2624 </span></a>            <span class="s3">return True</span>
2645 <a name="l2625"><span class="ln">2625 </span></a>        <span class="s3">except </span><span class="s1">ParseBaseException:</span>
2646 <a name="l2626"><span class="ln">2626 </span></a>            <span class="s3">return False</span>
2647 <a name="l2627"><span class="ln">2627 </span></a>
2648 <a name="l2628"><span class="ln">2628 </span></a>    <span class="s3">def </span><span class="s1">runTests(self</span><span class="s3">, </span><span class="s1">tests</span><span class="s3">, </span><span class="s1">parseAll=</span><span class="s3">True, </span><span class="s1">comment=</span><span class="s2">'#'</span><span class="s3">,</span>
2649 <a name="l2629"><span class="ln">2629 </span></a>                 <span class="s1">fullDump=</span><span class="s3">True, </span><span class="s1">printResults=</span><span class="s3">True, </span><span class="s1">failureTests=</span><span class="s3">False, </span><span class="s1">postParse=</span><span class="s3">None,</span>
2650 <a name="l2630"><span class="ln">2630 </span></a>                 <span class="s1">file=</span><span class="s3">None</span><span class="s1">):</span>
2651 <a name="l2631"><span class="ln">2631 </span></a>        <span class="s5">&quot;&quot;&quot; 
2652 <a name="l2632"><span class="ln">2632 </span></a>        Execute the parse expression on a series of test strings, showing each 
2653 <a name="l2633"><span class="ln">2633 </span></a>        test, the parsed results or where the parse failed. Quick and easy way to 
2654 <a name="l2634"><span class="ln">2634 </span></a>        run a parse expression against a list of sample strings. 
2655 <a name="l2635"><span class="ln">2635 </span></a> 
2656 <a name="l2636"><span class="ln">2636 </span></a>        Parameters: 
2657 <a name="l2637"><span class="ln">2637 </span></a>         - tests - a list of separate test strings, or a multiline string of test strings 
2658 <a name="l2638"><span class="ln">2638 </span></a>         - parseAll - (default= ``True``) - flag to pass to :class:`parseString` when running tests 
2659 <a name="l2639"><span class="ln">2639 </span></a>         - comment - (default= ``'#'``) - expression for indicating embedded comments in the test 
2660 <a name="l2640"><span class="ln">2640 </span></a>              string; pass None to disable comment filtering 
2661 <a name="l2641"><span class="ln">2641 </span></a>         - fullDump - (default= ``True``) - dump results as list followed by results names in nested outline; 
2662 <a name="l2642"><span class="ln">2642 </span></a>              if False, only dump nested list 
2663 <a name="l2643"><span class="ln">2643 </span></a>         - printResults - (default= ``True``) prints test output to stdout 
2664 <a name="l2644"><span class="ln">2644 </span></a>         - failureTests - (default= ``False``) indicates if these tests are expected to fail parsing 
2665 <a name="l2645"><span class="ln">2645 </span></a>         - postParse - (default= ``None``) optional callback for successful parse results; called as 
2666 <a name="l2646"><span class="ln">2646 </span></a>              `fn(test_string, parse_results)` and returns a string to be added to the test output 
2667 <a name="l2647"><span class="ln">2647 </span></a>         - file - (default=``None``) optional file-like object to which test output will be written; 
2668 <a name="l2648"><span class="ln">2648 </span></a>              if None, will default to ``sys.stdout`` 
2669 <a name="l2649"><span class="ln">2649 </span></a> 
2670 <a name="l2650"><span class="ln">2650 </span></a>        Returns: a (success, results) tuple, where success indicates that all tests succeeded 
2671 <a name="l2651"><span class="ln">2651 </span></a>        (or failed if ``failureTests`` is True), and the results contain a list of lines of each 
2672 <a name="l2652"><span class="ln">2652 </span></a>        test's output 
2673 <a name="l2653"><span class="ln">2653 </span></a> 
2674 <a name="l2654"><span class="ln">2654 </span></a>        Example:: 
2675 <a name="l2655"><span class="ln">2655 </span></a> 
2676 <a name="l2656"><span class="ln">2656 </span></a>            number_expr = pyparsing_common.number.copy() 
2677 <a name="l2657"><span class="ln">2657 </span></a> 
2678 <a name="l2658"><span class="ln">2658 </span></a>            result = number_expr.runTests(''' 
2679 <a name="l2659"><span class="ln">2659 </span></a>                # unsigned integer 
2680 <a name="l2660"><span class="ln">2660 </span></a>                100 
2681 <a name="l2661"><span class="ln">2661 </span></a>                # negative integer 
2682 <a name="l2662"><span class="ln">2662 </span></a>                -100 
2683 <a name="l2663"><span class="ln">2663 </span></a>                # float with scientific notation 
2684 <a name="l2664"><span class="ln">2664 </span></a>                6.02e23 
2685 <a name="l2665"><span class="ln">2665 </span></a>                # integer with scientific notation 
2686 <a name="l2666"><span class="ln">2666 </span></a>                1e-12 
2687 <a name="l2667"><span class="ln">2667 </span></a>                ''') 
2688 <a name="l2668"><span class="ln">2668 </span></a>            print(&quot;Success&quot; if result[0] else &quot;Failed!&quot;) 
2689 <a name="l2669"><span class="ln">2669 </span></a> 
2690 <a name="l2670"><span class="ln">2670 </span></a>            result = number_expr.runTests(''' 
2691 <a name="l2671"><span class="ln">2671 </span></a>                # stray character 
2692 <a name="l2672"><span class="ln">2672 </span></a>                100Z 
2693 <a name="l2673"><span class="ln">2673 </span></a>                # missing leading digit before '.' 
2694 <a name="l2674"><span class="ln">2674 </span></a>                -.100 
2695 <a name="l2675"><span class="ln">2675 </span></a>                # too many '.' 
2696 <a name="l2676"><span class="ln">2676 </span></a>                3.14.159 
2697 <a name="l2677"><span class="ln">2677 </span></a>                ''', failureTests=True) 
2698 <a name="l2678"><span class="ln">2678 </span></a>            print(&quot;Success&quot; if result[0] else &quot;Failed!&quot;) 
2699 <a name="l2679"><span class="ln">2679 </span></a> 
2700 <a name="l2680"><span class="ln">2680 </span></a>        prints:: 
2701 <a name="l2681"><span class="ln">2681 </span></a> 
2702 <a name="l2682"><span class="ln">2682 </span></a>            # unsigned integer 
2703 <a name="l2683"><span class="ln">2683 </span></a>            100 
2704 <a name="l2684"><span class="ln">2684 </span></a>            [100] 
2705 <a name="l2685"><span class="ln">2685 </span></a> 
2706 <a name="l2686"><span class="ln">2686 </span></a>            # negative integer 
2707 <a name="l2687"><span class="ln">2687 </span></a>            -100 
2708 <a name="l2688"><span class="ln">2688 </span></a>            [-100] 
2709 <a name="l2689"><span class="ln">2689 </span></a> 
2710 <a name="l2690"><span class="ln">2690 </span></a>            # float with scientific notation 
2711 <a name="l2691"><span class="ln">2691 </span></a>            6.02e23 
2712 <a name="l2692"><span class="ln">2692 </span></a>            [6.02e+23] 
2713 <a name="l2693"><span class="ln">2693 </span></a> 
2714 <a name="l2694"><span class="ln">2694 </span></a>            # integer with scientific notation 
2715 <a name="l2695"><span class="ln">2695 </span></a>            1e-12 
2716 <a name="l2696"><span class="ln">2696 </span></a>            [1e-12] 
2717 <a name="l2697"><span class="ln">2697 </span></a> 
2718 <a name="l2698"><span class="ln">2698 </span></a>            Success 
2719 <a name="l2699"><span class="ln">2699 </span></a> 
2720 <a name="l2700"><span class="ln">2700 </span></a>            # stray character 
2721 <a name="l2701"><span class="ln">2701 </span></a>            100Z 
2722 <a name="l2702"><span class="ln">2702 </span></a>               ^ 
2723 <a name="l2703"><span class="ln">2703 </span></a>            FAIL: Expected end of text (at char 3), (line:1, col:4) 
2724 <a name="l2704"><span class="ln">2704 </span></a> 
2725 <a name="l2705"><span class="ln">2705 </span></a>            # missing leading digit before '.' 
2726 <a name="l2706"><span class="ln">2706 </span></a>            -.100 
2727 <a name="l2707"><span class="ln">2707 </span></a>            ^ 
2728 <a name="l2708"><span class="ln">2708 </span></a>            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1) 
2729 <a name="l2709"><span class="ln">2709 </span></a> 
2730 <a name="l2710"><span class="ln">2710 </span></a>            # too many '.' 
2731 <a name="l2711"><span class="ln">2711 </span></a>            3.14.159 
2732 <a name="l2712"><span class="ln">2712 </span></a>                ^ 
2733 <a name="l2713"><span class="ln">2713 </span></a>            FAIL: Expected end of text (at char 4), (line:1, col:5) 
2734 <a name="l2714"><span class="ln">2714 </span></a> 
2735 <a name="l2715"><span class="ln">2715 </span></a>            Success 
2736 <a name="l2716"><span class="ln">2716 </span></a> 
2737 <a name="l2717"><span class="ln">2717 </span></a>        Each test string must be on a single line. If you want to test a string that spans multiple 
2738 <a name="l2718"><span class="ln">2718 </span></a>        lines, create a test like this:: 
2739 <a name="l2719"><span class="ln">2719 </span></a> 
2740 <a name="l2720"><span class="ln">2720 </span></a>            expr.runTest(r&quot;this is a test\\n of strings that spans \\n 3 lines&quot;) 
2741 <a name="l2721"><span class="ln">2721 </span></a> 
2742 <a name="l2722"><span class="ln">2722 </span></a>        (Note that this is a raw string literal, you must include the leading 'r'.) 
2743 <a name="l2723"><span class="ln">2723 </span></a>        &quot;&quot;&quot;</span>
2744 <a name="l2724"><span class="ln">2724 </span></a>        <span class="s3">if </span><span class="s1">isinstance(tests</span><span class="s3">, </span><span class="s1">basestring):</span>
2745 <a name="l2725"><span class="ln">2725 </span></a>            <span class="s1">tests = list(map(str.strip</span><span class="s3">, </span><span class="s1">tests.rstrip().splitlines()))</span>
2746 <a name="l2726"><span class="ln">2726 </span></a>        <span class="s3">if </span><span class="s1">isinstance(comment</span><span class="s3">, </span><span class="s1">basestring):</span>
2747 <a name="l2727"><span class="ln">2727 </span></a>            <span class="s1">comment = Literal(comment)</span>
2748 <a name="l2728"><span class="ln">2728 </span></a>        <span class="s3">if </span><span class="s1">file </span><span class="s3">is None</span><span class="s1">:</span>
2749 <a name="l2729"><span class="ln">2729 </span></a>            <span class="s1">file = sys.stdout</span>
2750 <a name="l2730"><span class="ln">2730 </span></a>        <span class="s1">print_ = file.write</span>
2751 <a name="l2731"><span class="ln">2731 </span></a>
2752 <a name="l2732"><span class="ln">2732 </span></a>        <span class="s1">allResults = []</span>
2753 <a name="l2733"><span class="ln">2733 </span></a>        <span class="s1">comments = []</span>
2754 <a name="l2734"><span class="ln">2734 </span></a>        <span class="s1">success = </span><span class="s3">True</span>
2755 <a name="l2735"><span class="ln">2735 </span></a>        <span class="s1">NL = Literal(</span><span class="s2">r'\n'</span><span class="s1">).addParseAction(replaceWith(</span><span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span><span class="s1">)).ignore(quotedString)</span>
2756 <a name="l2736"><span class="ln">2736 </span></a>        <span class="s1">BOM = </span><span class="s2">u'</span><span class="s3">\ufeff</span><span class="s2">'</span>
2757 <a name="l2737"><span class="ln">2737 </span></a>        <span class="s3">for </span><span class="s1">t </span><span class="s3">in </span><span class="s1">tests:</span>
2758 <a name="l2738"><span class="ln">2738 </span></a>            <span class="s3">if </span><span class="s1">comment </span><span class="s3">is not None and </span><span class="s1">comment.matches(t</span><span class="s3">, False</span><span class="s1">) </span><span class="s3">or </span><span class="s1">comments </span><span class="s3">and not </span><span class="s1">t:</span>
2759 <a name="l2739"><span class="ln">2739 </span></a>                <span class="s1">comments.append(t)</span>
2760 <a name="l2740"><span class="ln">2740 </span></a>                <span class="s3">continue</span>
2761 <a name="l2741"><span class="ln">2741 </span></a>            <span class="s3">if not </span><span class="s1">t:</span>
2762 <a name="l2742"><span class="ln">2742 </span></a>                <span class="s3">continue</span>
2763 <a name="l2743"><span class="ln">2743 </span></a>            <span class="s1">out = [</span><span class="s2">'</span><span class="s3">\n</span><span class="s2">' </span><span class="s1">+ </span><span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span><span class="s1">.join(comments) </span><span class="s3">if </span><span class="s1">comments </span><span class="s3">else </span><span class="s2">''</span><span class="s3">, </span><span class="s1">t]</span>
2764 <a name="l2744"><span class="ln">2744 </span></a>            <span class="s1">comments = []</span>
2765 <a name="l2745"><span class="ln">2745 </span></a>            <span class="s3">try</span><span class="s1">:</span>
2766 <a name="l2746"><span class="ln">2746 </span></a>                <span class="s0"># convert newline marks to actual newlines, and strip leading BOM if present</span>
2767 <a name="l2747"><span class="ln">2747 </span></a>                <span class="s1">t = NL.transformString(t.lstrip(BOM))</span>
2768 <a name="l2748"><span class="ln">2748 </span></a>                <span class="s1">result = self.parseString(t</span><span class="s3">, </span><span class="s1">parseAll=parseAll)</span>
2769 <a name="l2749"><span class="ln">2749 </span></a>            <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">pe:</span>
2770 <a name="l2750"><span class="ln">2750 </span></a>                <span class="s1">fatal = </span><span class="s2">&quot;(FATAL)&quot; </span><span class="s3">if </span><span class="s1">isinstance(pe</span><span class="s3">, </span><span class="s1">ParseFatalException) </span><span class="s3">else </span><span class="s2">&quot;&quot;</span>
2771 <a name="l2751"><span class="ln">2751 </span></a>                <span class="s3">if </span><span class="s2">'</span><span class="s3">\n</span><span class="s2">' </span><span class="s3">in </span><span class="s1">t:</span>
2772 <a name="l2752"><span class="ln">2752 </span></a>                    <span class="s1">out.append(line(pe.loc</span><span class="s3">, </span><span class="s1">t))</span>
2773 <a name="l2753"><span class="ln">2753 </span></a>                    <span class="s1">out.append(</span><span class="s2">' ' </span><span class="s1">* (col(pe.loc</span><span class="s3">, </span><span class="s1">t) - </span><span class="s4">1</span><span class="s1">) + </span><span class="s2">'^' </span><span class="s1">+ fatal)</span>
2774 <a name="l2754"><span class="ln">2754 </span></a>                <span class="s3">else</span><span class="s1">:</span>
2775 <a name="l2755"><span class="ln">2755 </span></a>                    <span class="s1">out.append(</span><span class="s2">' ' </span><span class="s1">* pe.loc + </span><span class="s2">'^' </span><span class="s1">+ fatal)</span>
2776 <a name="l2756"><span class="ln">2756 </span></a>                <span class="s1">out.append(</span><span class="s2">&quot;FAIL: &quot; </span><span class="s1">+ str(pe))</span>
2777 <a name="l2757"><span class="ln">2757 </span></a>                <span class="s1">success = success </span><span class="s3">and </span><span class="s1">failureTests</span>
2778 <a name="l2758"><span class="ln">2758 </span></a>                <span class="s1">result = pe</span>
2779 <a name="l2759"><span class="ln">2759 </span></a>            <span class="s3">except </span><span class="s1">Exception </span><span class="s3">as </span><span class="s1">exc:</span>
2780 <a name="l2760"><span class="ln">2760 </span></a>                <span class="s1">out.append(</span><span class="s2">&quot;FAIL-EXCEPTION: &quot; </span><span class="s1">+ str(exc))</span>
2781 <a name="l2761"><span class="ln">2761 </span></a>                <span class="s1">success = success </span><span class="s3">and </span><span class="s1">failureTests</span>
2782 <a name="l2762"><span class="ln">2762 </span></a>                <span class="s1">result = exc</span>
2783 <a name="l2763"><span class="ln">2763 </span></a>            <span class="s3">else</span><span class="s1">:</span>
2784 <a name="l2764"><span class="ln">2764 </span></a>                <span class="s1">success = success </span><span class="s3">and not </span><span class="s1">failureTests</span>
2785 <a name="l2765"><span class="ln">2765 </span></a>                <span class="s3">if </span><span class="s1">postParse </span><span class="s3">is not None</span><span class="s1">:</span>
2786 <a name="l2766"><span class="ln">2766 </span></a>                    <span class="s3">try</span><span class="s1">:</span>
2787 <a name="l2767"><span class="ln">2767 </span></a>                        <span class="s1">pp_value = postParse(t</span><span class="s3">, </span><span class="s1">result)</span>
2788 <a name="l2768"><span class="ln">2768 </span></a>                        <span class="s3">if </span><span class="s1">pp_value </span><span class="s3">is not None</span><span class="s1">:</span>
2789 <a name="l2769"><span class="ln">2769 </span></a>                            <span class="s3">if </span><span class="s1">isinstance(pp_value</span><span class="s3">, </span><span class="s1">ParseResults):</span>
2790 <a name="l2770"><span class="ln">2770 </span></a>                                <span class="s1">out.append(pp_value.dump())</span>
2791 <a name="l2771"><span class="ln">2771 </span></a>                            <span class="s3">else</span><span class="s1">:</span>
2792 <a name="l2772"><span class="ln">2772 </span></a>                                <span class="s1">out.append(str(pp_value))</span>
2793 <a name="l2773"><span class="ln">2773 </span></a>                        <span class="s3">else</span><span class="s1">:</span>
2794 <a name="l2774"><span class="ln">2774 </span></a>                            <span class="s1">out.append(result.dump())</span>
2795 <a name="l2775"><span class="ln">2775 </span></a>                    <span class="s3">except </span><span class="s1">Exception </span><span class="s3">as </span><span class="s1">e:</span>
2796 <a name="l2776"><span class="ln">2776 </span></a>                        <span class="s1">out.append(result.dump(full=fullDump))</span>
2797 <a name="l2777"><span class="ln">2777 </span></a>                        <span class="s1">out.append(</span><span class="s2">&quot;{0} failed: {1}: {2}&quot;</span><span class="s1">.format(postParse.__name__</span><span class="s3">, </span><span class="s1">type(e).__name__</span><span class="s3">, </span><span class="s1">e))</span>
2798 <a name="l2778"><span class="ln">2778 </span></a>                <span class="s3">else</span><span class="s1">:</span>
2799 <a name="l2779"><span class="ln">2779 </span></a>                    <span class="s1">out.append(result.dump(full=fullDump))</span>
2800 <a name="l2780"><span class="ln">2780 </span></a>
2801 <a name="l2781"><span class="ln">2781 </span></a>            <span class="s3">if </span><span class="s1">printResults:</span>
2802 <a name="l2782"><span class="ln">2782 </span></a>                <span class="s3">if </span><span class="s1">fullDump:</span>
2803 <a name="l2783"><span class="ln">2783 </span></a>                    <span class="s1">out.append(</span><span class="s2">''</span><span class="s1">)</span>
2804 <a name="l2784"><span class="ln">2784 </span></a>                <span class="s1">print_(</span><span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span><span class="s1">.join(out))</span>
2805 <a name="l2785"><span class="ln">2785 </span></a>
2806 <a name="l2786"><span class="ln">2786 </span></a>            <span class="s1">allResults.append((t</span><span class="s3">, </span><span class="s1">result))</span>
2807 <a name="l2787"><span class="ln">2787 </span></a>
2808 <a name="l2788"><span class="ln">2788 </span></a>        <span class="s3">return </span><span class="s1">success</span><span class="s3">, </span><span class="s1">allResults</span>
2809 <a name="l2789"><span class="ln">2789 </span></a>
2810 <a name="l2790"><span class="ln">2790 </span></a>
2811 <a name="l2791"><span class="ln">2791 </span></a><span class="s3">class </span><span class="s1">_PendingSkip(ParserElement):</span>
2812 <a name="l2792"><span class="ln">2792 </span></a>    <span class="s0"># internal placeholder class to hold a place were '...' is added to a parser element,</span>
2813 <a name="l2793"><span class="ln">2793 </span></a>    <span class="s0"># once another ParserElement is added, this placeholder will be replaced with a SkipTo</span>
2814 <a name="l2794"><span class="ln">2794 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">must_skip=</span><span class="s3">False</span><span class="s1">):</span>
2815 <a name="l2795"><span class="ln">2795 </span></a>        <span class="s1">super(_PendingSkip</span><span class="s3">, </span><span class="s1">self).__init__()</span>
2816 <a name="l2796"><span class="ln">2796 </span></a>        <span class="s1">self.strRepr = str(expr + Empty()).replace(</span><span class="s2">'Empty'</span><span class="s3">, </span><span class="s2">'...'</span><span class="s1">)</span>
2817 <a name="l2797"><span class="ln">2797 </span></a>        <span class="s1">self.name = self.strRepr</span>
2818 <a name="l2798"><span class="ln">2798 </span></a>        <span class="s1">self.anchor = expr</span>
2819 <a name="l2799"><span class="ln">2799 </span></a>        <span class="s1">self.must_skip = must_skip</span>
2820 <a name="l2800"><span class="ln">2800 </span></a>
2821 <a name="l2801"><span class="ln">2801 </span></a>    <span class="s3">def </span><span class="s1">__add__(self</span><span class="s3">, </span><span class="s1">other):</span>
2822 <a name="l2802"><span class="ln">2802 </span></a>        <span class="s1">skipper = SkipTo(other).setName(</span><span class="s2">&quot;...&quot;</span><span class="s1">)(</span><span class="s2">&quot;_skipped*&quot;</span><span class="s1">)</span>
2823 <a name="l2803"><span class="ln">2803 </span></a>        <span class="s3">if </span><span class="s1">self.must_skip:</span>
2824 <a name="l2804"><span class="ln">2804 </span></a>            <span class="s3">def </span><span class="s1">must_skip(t):</span>
2825 <a name="l2805"><span class="ln">2805 </span></a>                <span class="s3">if not </span><span class="s1">t._skipped </span><span class="s3">or </span><span class="s1">t._skipped.asList() == [</span><span class="s2">''</span><span class="s1">]:</span>
2826 <a name="l2806"><span class="ln">2806 </span></a>                    <span class="s3">del </span><span class="s1">t[</span><span class="s4">0</span><span class="s1">]</span>
2827 <a name="l2807"><span class="ln">2807 </span></a>                    <span class="s1">t.pop(</span><span class="s2">&quot;_skipped&quot;</span><span class="s3">, None</span><span class="s1">)</span>
2828 <a name="l2808"><span class="ln">2808 </span></a>            <span class="s3">def </span><span class="s1">show_skip(t):</span>
2829 <a name="l2809"><span class="ln">2809 </span></a>                <span class="s3">if </span><span class="s1">t._skipped.asList()[-</span><span class="s4">1</span><span class="s1">:] == [</span><span class="s2">''</span><span class="s1">]:</span>
2830 <a name="l2810"><span class="ln">2810 </span></a>                    <span class="s1">skipped = t.pop(</span><span class="s2">'_skipped'</span><span class="s1">)</span>
2831 <a name="l2811"><span class="ln">2811 </span></a>                    <span class="s1">t[</span><span class="s2">'_skipped'</span><span class="s1">] = </span><span class="s2">'missing &lt;' </span><span class="s1">+ repr(self.anchor) + </span><span class="s2">'&gt;'</span>
2832 <a name="l2812"><span class="ln">2812 </span></a>            <span class="s3">return </span><span class="s1">(self.anchor + skipper().addParseAction(must_skip)</span>
2833 <a name="l2813"><span class="ln">2813 </span></a>                    <span class="s1">| skipper().addParseAction(show_skip)) + other</span>
2834 <a name="l2814"><span class="ln">2814 </span></a>
2835 <a name="l2815"><span class="ln">2815 </span></a>        <span class="s3">return </span><span class="s1">self.anchor + skipper + other</span>
2836 <a name="l2816"><span class="ln">2816 </span></a>
2837 <a name="l2817"><span class="ln">2817 </span></a>    <span class="s3">def </span><span class="s1">__repr__(self):</span>
2838 <a name="l2818"><span class="ln">2818 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
2839 <a name="l2819"><span class="ln">2819 </span></a>
2840 <a name="l2820"><span class="ln">2820 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">*args):</span>
2841 <a name="l2821"><span class="ln">2821 </span></a>        <span class="s3">raise </span><span class="s1">Exception(</span><span class="s2">&quot;use of `...` expression without following SkipTo target expression&quot;</span><span class="s1">)</span>
2842 <a name="l2822"><span class="ln">2822 </span></a>
2843 <a name="l2823"><span class="ln">2823 </span></a>
2844 <a name="l2824"><span class="ln">2824 </span></a><span class="s3">class </span><span class="s1">Token(ParserElement):</span>
2845 <a name="l2825"><span class="ln">2825 </span></a>    <span class="s5">&quot;&quot;&quot;Abstract :class:`ParserElement` subclass, for defining atomic 
2846 <a name="l2826"><span class="ln">2826 </span></a>    matching patterns. 
2847 <a name="l2827"><span class="ln">2827 </span></a>    &quot;&quot;&quot;</span>
2848 <a name="l2828"><span class="ln">2828 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
2849 <a name="l2829"><span class="ln">2829 </span></a>        <span class="s1">super(Token</span><span class="s3">, </span><span class="s1">self).__init__(savelist=</span><span class="s3">False</span><span class="s1">)</span>
2850 <a name="l2830"><span class="ln">2830 </span></a>
2851 <a name="l2831"><span class="ln">2831 </span></a>
2852 <a name="l2832"><span class="ln">2832 </span></a><span class="s3">class </span><span class="s1">Empty(Token):</span>
2853 <a name="l2833"><span class="ln">2833 </span></a>    <span class="s5">&quot;&quot;&quot;An empty token, will always match. 
2854 <a name="l2834"><span class="ln">2834 </span></a>    &quot;&quot;&quot;</span>
2855 <a name="l2835"><span class="ln">2835 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
2856 <a name="l2836"><span class="ln">2836 </span></a>        <span class="s1">super(Empty</span><span class="s3">, </span><span class="s1">self).__init__()</span>
2857 <a name="l2837"><span class="ln">2837 </span></a>        <span class="s1">self.name = </span><span class="s2">&quot;Empty&quot;</span>
2858 <a name="l2838"><span class="ln">2838 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
2859 <a name="l2839"><span class="ln">2839 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
2860 <a name="l2840"><span class="ln">2840 </span></a>
2861 <a name="l2841"><span class="ln">2841 </span></a>
2862 <a name="l2842"><span class="ln">2842 </span></a><span class="s3">class </span><span class="s1">NoMatch(Token):</span>
2863 <a name="l2843"><span class="ln">2843 </span></a>    <span class="s5">&quot;&quot;&quot;A token that will never match. 
2864 <a name="l2844"><span class="ln">2844 </span></a>    &quot;&quot;&quot;</span>
2865 <a name="l2845"><span class="ln">2845 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
2866 <a name="l2846"><span class="ln">2846 </span></a>        <span class="s1">super(NoMatch</span><span class="s3">, </span><span class="s1">self).__init__()</span>
2867 <a name="l2847"><span class="ln">2847 </span></a>        <span class="s1">self.name = </span><span class="s2">&quot;NoMatch&quot;</span>
2868 <a name="l2848"><span class="ln">2848 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
2869 <a name="l2849"><span class="ln">2849 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
2870 <a name="l2850"><span class="ln">2850 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Unmatchable token&quot;</span>
2871 <a name="l2851"><span class="ln">2851 </span></a>
2872 <a name="l2852"><span class="ln">2852 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
2873 <a name="l2853"><span class="ln">2853 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
2874 <a name="l2854"><span class="ln">2854 </span></a>
2875 <a name="l2855"><span class="ln">2855 </span></a>
2876 <a name="l2856"><span class="ln">2856 </span></a><span class="s3">class </span><span class="s1">Literal(Token):</span>
2877 <a name="l2857"><span class="ln">2857 </span></a>    <span class="s5">&quot;&quot;&quot;Token to exactly match a specified string. 
2878 <a name="l2858"><span class="ln">2858 </span></a> 
2879 <a name="l2859"><span class="ln">2859 </span></a>    Example:: 
2880 <a name="l2860"><span class="ln">2860 </span></a> 
2881 <a name="l2861"><span class="ln">2861 </span></a>        Literal('blah').parseString('blah')  # -&gt; ['blah'] 
2882 <a name="l2862"><span class="ln">2862 </span></a>        Literal('blah').parseString('blahfooblah')  # -&gt; ['blah'] 
2883 <a name="l2863"><span class="ln">2863 </span></a>        Literal('blah').parseString('bla')  # -&gt; Exception: Expected &quot;blah&quot; 
2884 <a name="l2864"><span class="ln">2864 </span></a> 
2885 <a name="l2865"><span class="ln">2865 </span></a>    For case-insensitive matching, use :class:`CaselessLiteral`. 
2886 <a name="l2866"><span class="ln">2866 </span></a> 
2887 <a name="l2867"><span class="ln">2867 </span></a>    For keyword matching (force word break before and after the matched string), 
2888 <a name="l2868"><span class="ln">2868 </span></a>    use :class:`Keyword` or :class:`CaselessKeyword`. 
2889 <a name="l2869"><span class="ln">2869 </span></a>    &quot;&quot;&quot;</span>
2890 <a name="l2870"><span class="ln">2870 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">matchString):</span>
2891 <a name="l2871"><span class="ln">2871 </span></a>        <span class="s1">super(Literal</span><span class="s3">, </span><span class="s1">self).__init__()</span>
2892 <a name="l2872"><span class="ln">2872 </span></a>        <span class="s1">self.match = matchString</span>
2893 <a name="l2873"><span class="ln">2873 </span></a>        <span class="s1">self.matchLen = len(matchString)</span>
2894 <a name="l2874"><span class="ln">2874 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2895 <a name="l2875"><span class="ln">2875 </span></a>            <span class="s1">self.firstMatchChar = matchString[</span><span class="s4">0</span><span class="s1">]</span>
2896 <a name="l2876"><span class="ln">2876 </span></a>        <span class="s3">except </span><span class="s1">IndexError:</span>
2897 <a name="l2877"><span class="ln">2877 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;null string passed to Literal; use Empty() instead&quot;</span><span class="s3">,</span>
2898 <a name="l2878"><span class="ln">2878 </span></a>                            <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2899 <a name="l2879"><span class="ln">2879 </span></a>            <span class="s1">self.__class__ = Empty</span>
2900 <a name="l2880"><span class="ln">2880 </span></a>        <span class="s1">self.name = </span><span class="s2">'&quot;%s&quot;' </span><span class="s1">% _ustr(self.match)</span>
2901 <a name="l2881"><span class="ln">2881 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
2902 <a name="l2882"><span class="ln">2882 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">False</span>
2903 <a name="l2883"><span class="ln">2883 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
2904 <a name="l2884"><span class="ln">2884 </span></a>
2905 <a name="l2885"><span class="ln">2885 </span></a>        <span class="s0"># Performance tuning: modify __class__ to select</span>
2906 <a name="l2886"><span class="ln">2886 </span></a>        <span class="s0"># a parseImpl optimized for single-character check</span>
2907 <a name="l2887"><span class="ln">2887 </span></a>        <span class="s3">if </span><span class="s1">self.matchLen == </span><span class="s4">1 </span><span class="s3">and </span><span class="s1">type(self) </span><span class="s3">is </span><span class="s1">Literal:</span>
2908 <a name="l2888"><span class="ln">2888 </span></a>            <span class="s1">self.__class__ = _SingleCharLiteral</span>
2909 <a name="l2889"><span class="ln">2889 </span></a>
2910 <a name="l2890"><span class="ln">2890 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
2911 <a name="l2891"><span class="ln">2891 </span></a>        <span class="s3">if </span><span class="s1">instring[loc] == self.firstMatchChar </span><span class="s3">and </span><span class="s1">instring.startswith(self.match</span><span class="s3">, </span><span class="s1">loc):</span>
2912 <a name="l2892"><span class="ln">2892 </span></a>            <span class="s3">return </span><span class="s1">loc + self.matchLen</span><span class="s3">, </span><span class="s1">self.match</span>
2913 <a name="l2893"><span class="ln">2893 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
2914 <a name="l2894"><span class="ln">2894 </span></a>
2915 <a name="l2895"><span class="ln">2895 </span></a><span class="s3">class </span><span class="s1">_SingleCharLiteral(Literal):</span>
2916 <a name="l2896"><span class="ln">2896 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
2917 <a name="l2897"><span class="ln">2897 </span></a>        <span class="s3">if </span><span class="s1">instring[loc] == self.firstMatchChar:</span>
2918 <a name="l2898"><span class="ln">2898 </span></a>            <span class="s3">return </span><span class="s1">loc + </span><span class="s4">1</span><span class="s3">, </span><span class="s1">self.match</span>
2919 <a name="l2899"><span class="ln">2899 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
2920 <a name="l2900"><span class="ln">2900 </span></a>
2921 <a name="l2901"><span class="ln">2901 </span></a><span class="s1">_L = Literal</span>
2922 <a name="l2902"><span class="ln">2902 </span></a><span class="s1">ParserElement._literalStringClass = Literal</span>
2923 <a name="l2903"><span class="ln">2903 </span></a>
2924 <a name="l2904"><span class="ln">2904 </span></a><span class="s3">class </span><span class="s1">Keyword(Token):</span>
2925 <a name="l2905"><span class="ln">2905 </span></a>    <span class="s5">&quot;&quot;&quot;Token to exactly match a specified string as a keyword, that is, 
2926 <a name="l2906"><span class="ln">2906 </span></a>    it must be immediately followed by a non-keyword character.  Compare 
2927 <a name="l2907"><span class="ln">2907 </span></a>    with :class:`Literal`: 
2928 <a name="l2908"><span class="ln">2908 </span></a> 
2929 <a name="l2909"><span class="ln">2909 </span></a>     - ``Literal(&quot;if&quot;)`` will match the leading ``'if'`` in 
2930 <a name="l2910"><span class="ln">2910 </span></a>       ``'ifAndOnlyIf'``. 
2931 <a name="l2911"><span class="ln">2911 </span></a>     - ``Keyword(&quot;if&quot;)`` will not; it will only match the leading 
2932 <a name="l2912"><span class="ln">2912 </span></a>       ``'if'`` in ``'if x=1'``, or ``'if(y==2)'`` 
2933 <a name="l2913"><span class="ln">2913 </span></a> 
2934 <a name="l2914"><span class="ln">2914 </span></a>    Accepts two optional constructor arguments in addition to the 
2935 <a name="l2915"><span class="ln">2915 </span></a>    keyword string: 
2936 <a name="l2916"><span class="ln">2916 </span></a> 
2937 <a name="l2917"><span class="ln">2917 </span></a>     - ``identChars`` is a string of characters that would be valid 
2938 <a name="l2918"><span class="ln">2918 </span></a>       identifier characters, defaulting to all alphanumerics + &quot;_&quot; and 
2939 <a name="l2919"><span class="ln">2919 </span></a>       &quot;$&quot; 
2940 <a name="l2920"><span class="ln">2920 </span></a>     - ``caseless`` allows case-insensitive matching, default is ``False``. 
2941 <a name="l2921"><span class="ln">2921 </span></a> 
2942 <a name="l2922"><span class="ln">2922 </span></a>    Example:: 
2943 <a name="l2923"><span class="ln">2923 </span></a> 
2944 <a name="l2924"><span class="ln">2924 </span></a>        Keyword(&quot;start&quot;).parseString(&quot;start&quot;)  # -&gt; ['start'] 
2945 <a name="l2925"><span class="ln">2925 </span></a>        Keyword(&quot;start&quot;).parseString(&quot;starting&quot;)  # -&gt; Exception 
2946 <a name="l2926"><span class="ln">2926 </span></a> 
2947 <a name="l2927"><span class="ln">2927 </span></a>    For case-insensitive matching, use :class:`CaselessKeyword`. 
2948 <a name="l2928"><span class="ln">2928 </span></a>    &quot;&quot;&quot;</span>
2949 <a name="l2929"><span class="ln">2929 </span></a>    <span class="s1">DEFAULT_KEYWORD_CHARS = alphanums + </span><span class="s2">&quot;_$&quot;</span>
2950 <a name="l2930"><span class="ln">2930 </span></a>
2951 <a name="l2931"><span class="ln">2931 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">matchString</span><span class="s3">, </span><span class="s1">identChars=</span><span class="s3">None, </span><span class="s1">caseless=</span><span class="s3">False</span><span class="s1">):</span>
2952 <a name="l2932"><span class="ln">2932 </span></a>        <span class="s1">super(Keyword</span><span class="s3">, </span><span class="s1">self).__init__()</span>
2953 <a name="l2933"><span class="ln">2933 </span></a>        <span class="s3">if </span><span class="s1">identChars </span><span class="s3">is None</span><span class="s1">:</span>
2954 <a name="l2934"><span class="ln">2934 </span></a>            <span class="s1">identChars = Keyword.DEFAULT_KEYWORD_CHARS</span>
2955 <a name="l2935"><span class="ln">2935 </span></a>        <span class="s1">self.match = matchString</span>
2956 <a name="l2936"><span class="ln">2936 </span></a>        <span class="s1">self.matchLen = len(matchString)</span>
2957 <a name="l2937"><span class="ln">2937 </span></a>        <span class="s3">try</span><span class="s1">:</span>
2958 <a name="l2938"><span class="ln">2938 </span></a>            <span class="s1">self.firstMatchChar = matchString[</span><span class="s4">0</span><span class="s1">]</span>
2959 <a name="l2939"><span class="ln">2939 </span></a>        <span class="s3">except </span><span class="s1">IndexError:</span>
2960 <a name="l2940"><span class="ln">2940 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;null string passed to Keyword; use Empty() instead&quot;</span><span class="s3">,</span>
2961 <a name="l2941"><span class="ln">2941 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
2962 <a name="l2942"><span class="ln">2942 </span></a>        <span class="s1">self.name = </span><span class="s2">'&quot;%s&quot;' </span><span class="s1">% self.match</span>
2963 <a name="l2943"><span class="ln">2943 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
2964 <a name="l2944"><span class="ln">2944 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">False</span>
2965 <a name="l2945"><span class="ln">2945 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
2966 <a name="l2946"><span class="ln">2946 </span></a>        <span class="s1">self.caseless = caseless</span>
2967 <a name="l2947"><span class="ln">2947 </span></a>        <span class="s3">if </span><span class="s1">caseless:</span>
2968 <a name="l2948"><span class="ln">2948 </span></a>            <span class="s1">self.caselessmatch = matchString.upper()</span>
2969 <a name="l2949"><span class="ln">2949 </span></a>            <span class="s1">identChars = identChars.upper()</span>
2970 <a name="l2950"><span class="ln">2950 </span></a>        <span class="s1">self.identChars = set(identChars)</span>
2971 <a name="l2951"><span class="ln">2951 </span></a>
2972 <a name="l2952"><span class="ln">2952 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
2973 <a name="l2953"><span class="ln">2953 </span></a>        <span class="s3">if </span><span class="s1">self.caseless:</span>
2974 <a name="l2954"><span class="ln">2954 </span></a>            <span class="s3">if </span><span class="s1">((instring[loc:loc + self.matchLen].upper() == self.caselessmatch)</span>
2975 <a name="l2955"><span class="ln">2955 </span></a>                    <span class="s3">and </span><span class="s1">(loc &gt;= len(instring) - self.matchLen</span>
2976 <a name="l2956"><span class="ln">2956 </span></a>                         <span class="s3">or </span><span class="s1">instring[loc + self.matchLen].upper() </span><span class="s3">not in </span><span class="s1">self.identChars)</span>
2977 <a name="l2957"><span class="ln">2957 </span></a>                    <span class="s3">and </span><span class="s1">(loc == </span><span class="s4">0</span>
2978 <a name="l2958"><span class="ln">2958 </span></a>                         <span class="s3">or </span><span class="s1">instring[loc - </span><span class="s4">1</span><span class="s1">].upper() </span><span class="s3">not in </span><span class="s1">self.identChars)):</span>
2979 <a name="l2959"><span class="ln">2959 </span></a>                <span class="s3">return </span><span class="s1">loc + self.matchLen</span><span class="s3">, </span><span class="s1">self.match</span>
2980 <a name="l2960"><span class="ln">2960 </span></a>
2981 <a name="l2961"><span class="ln">2961 </span></a>        <span class="s3">else</span><span class="s1">:</span>
2982 <a name="l2962"><span class="ln">2962 </span></a>            <span class="s3">if </span><span class="s1">instring[loc] == self.firstMatchChar:</span>
2983 <a name="l2963"><span class="ln">2963 </span></a>                <span class="s3">if </span><span class="s1">((self.matchLen == </span><span class="s4">1 </span><span class="s3">or </span><span class="s1">instring.startswith(self.match</span><span class="s3">, </span><span class="s1">loc))</span>
2984 <a name="l2964"><span class="ln">2964 </span></a>                        <span class="s3">and </span><span class="s1">(loc &gt;= len(instring) - self.matchLen</span>
2985 <a name="l2965"><span class="ln">2965 </span></a>                             <span class="s3">or </span><span class="s1">instring[loc + self.matchLen] </span><span class="s3">not in </span><span class="s1">self.identChars)</span>
2986 <a name="l2966"><span class="ln">2966 </span></a>                        <span class="s3">and </span><span class="s1">(loc == </span><span class="s4">0 </span><span class="s3">or </span><span class="s1">instring[loc - </span><span class="s4">1</span><span class="s1">] </span><span class="s3">not in </span><span class="s1">self.identChars)):</span>
2987 <a name="l2967"><span class="ln">2967 </span></a>                    <span class="s3">return </span><span class="s1">loc + self.matchLen</span><span class="s3">, </span><span class="s1">self.match</span>
2988 <a name="l2968"><span class="ln">2968 </span></a>
2989 <a name="l2969"><span class="ln">2969 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
2990 <a name="l2970"><span class="ln">2970 </span></a>
2991 <a name="l2971"><span class="ln">2971 </span></a>    <span class="s3">def </span><span class="s1">copy(self):</span>
2992 <a name="l2972"><span class="ln">2972 </span></a>        <span class="s1">c = super(Keyword</span><span class="s3">, </span><span class="s1">self).copy()</span>
2993 <a name="l2973"><span class="ln">2973 </span></a>        <span class="s1">c.identChars = Keyword.DEFAULT_KEYWORD_CHARS</span>
2994 <a name="l2974"><span class="ln">2974 </span></a>        <span class="s3">return </span><span class="s1">c</span>
2995 <a name="l2975"><span class="ln">2975 </span></a>
2996 <a name="l2976"><span class="ln">2976 </span></a>    <span class="s1">@staticmethod</span>
2997 <a name="l2977"><span class="ln">2977 </span></a>    <span class="s3">def </span><span class="s1">setDefaultKeywordChars(chars):</span>
2998 <a name="l2978"><span class="ln">2978 </span></a>        <span class="s5">&quot;&quot;&quot;Overrides the default Keyword chars 
2999 <a name="l2979"><span class="ln">2979 </span></a>        &quot;&quot;&quot;</span>
3000 <a name="l2980"><span class="ln">2980 </span></a>        <span class="s1">Keyword.DEFAULT_KEYWORD_CHARS = chars</span>
3001 <a name="l2981"><span class="ln">2981 </span></a>
3002 <a name="l2982"><span class="ln">2982 </span></a><span class="s3">class </span><span class="s1">CaselessLiteral(Literal):</span>
3003 <a name="l2983"><span class="ln">2983 </span></a>    <span class="s5">&quot;&quot;&quot;Token to match a specified string, ignoring case of letters. 
3004 <a name="l2984"><span class="ln">2984 </span></a>    Note: the matched results will always be in the case of the given 
3005 <a name="l2985"><span class="ln">2985 </span></a>    match string, NOT the case of the input text. 
3006 <a name="l2986"><span class="ln">2986 </span></a> 
3007 <a name="l2987"><span class="ln">2987 </span></a>    Example:: 
3008 <a name="l2988"><span class="ln">2988 </span></a> 
3009 <a name="l2989"><span class="ln">2989 </span></a>        OneOrMore(CaselessLiteral(&quot;CMD&quot;)).parseString(&quot;cmd CMD Cmd10&quot;) # -&gt; ['CMD', 'CMD', 'CMD'] 
3010 <a name="l2990"><span class="ln">2990 </span></a> 
3011 <a name="l2991"><span class="ln">2991 </span></a>    (Contrast with example for :class:`CaselessKeyword`.) 
3012 <a name="l2992"><span class="ln">2992 </span></a>    &quot;&quot;&quot;</span>
3013 <a name="l2993"><span class="ln">2993 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">matchString):</span>
3014 <a name="l2994"><span class="ln">2994 </span></a>        <span class="s1">super(CaselessLiteral</span><span class="s3">, </span><span class="s1">self).__init__(matchString.upper())</span>
3015 <a name="l2995"><span class="ln">2995 </span></a>        <span class="s0"># Preserve the defining literal.</span>
3016 <a name="l2996"><span class="ln">2996 </span></a>        <span class="s1">self.returnString = matchString</span>
3017 <a name="l2997"><span class="ln">2997 </span></a>        <span class="s1">self.name = </span><span class="s2">&quot;'%s'&quot; </span><span class="s1">% self.returnString</span>
3018 <a name="l2998"><span class="ln">2998 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
3019 <a name="l2999"><span class="ln">2999 </span></a>
3020 <a name="l3000"><span class="ln">3000 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3021 <a name="l3001"><span class="ln">3001 </span></a>        <span class="s3">if </span><span class="s1">instring[loc:loc + self.matchLen].upper() == self.match:</span>
3022 <a name="l3002"><span class="ln">3002 </span></a>            <span class="s3">return </span><span class="s1">loc + self.matchLen</span><span class="s3">, </span><span class="s1">self.returnString</span>
3023 <a name="l3003"><span class="ln">3003 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3024 <a name="l3004"><span class="ln">3004 </span></a>
3025 <a name="l3005"><span class="ln">3005 </span></a><span class="s3">class </span><span class="s1">CaselessKeyword(Keyword):</span>
3026 <a name="l3006"><span class="ln">3006 </span></a>    <span class="s5">&quot;&quot;&quot; 
3027 <a name="l3007"><span class="ln">3007 </span></a>    Caseless version of :class:`Keyword`. 
3028 <a name="l3008"><span class="ln">3008 </span></a> 
3029 <a name="l3009"><span class="ln">3009 </span></a>    Example:: 
3030 <a name="l3010"><span class="ln">3010 </span></a> 
3031 <a name="l3011"><span class="ln">3011 </span></a>        OneOrMore(CaselessKeyword(&quot;CMD&quot;)).parseString(&quot;cmd CMD Cmd10&quot;) # -&gt; ['CMD', 'CMD'] 
3032 <a name="l3012"><span class="ln">3012 </span></a> 
3033 <a name="l3013"><span class="ln">3013 </span></a>    (Contrast with example for :class:`CaselessLiteral`.) 
3034 <a name="l3014"><span class="ln">3014 </span></a>    &quot;&quot;&quot;</span>
3035 <a name="l3015"><span class="ln">3015 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">matchString</span><span class="s3">, </span><span class="s1">identChars=</span><span class="s3">None</span><span class="s1">):</span>
3036 <a name="l3016"><span class="ln">3016 </span></a>        <span class="s1">super(CaselessKeyword</span><span class="s3">, </span><span class="s1">self).__init__(matchString</span><span class="s3">, </span><span class="s1">identChars</span><span class="s3">, </span><span class="s1">caseless=</span><span class="s3">True</span><span class="s1">)</span>
3037 <a name="l3017"><span class="ln">3017 </span></a>
3038 <a name="l3018"><span class="ln">3018 </span></a><span class="s3">class </span><span class="s1">CloseMatch(Token):</span>
3039 <a name="l3019"><span class="ln">3019 </span></a>    <span class="s5">&quot;&quot;&quot;A variation on :class:`Literal` which matches &quot;close&quot; matches, 
3040 <a name="l3020"><span class="ln">3020 </span></a>    that is, strings with at most 'n' mismatching characters. 
3041 <a name="l3021"><span class="ln">3021 </span></a>    :class:`CloseMatch` takes parameters: 
3042 <a name="l3022"><span class="ln">3022 </span></a> 
3043 <a name="l3023"><span class="ln">3023 </span></a>     - ``match_string`` - string to be matched 
3044 <a name="l3024"><span class="ln">3024 </span></a>     - ``maxMismatches`` - (``default=1``) maximum number of 
3045 <a name="l3025"><span class="ln">3025 </span></a>       mismatches allowed to count as a match 
3046 <a name="l3026"><span class="ln">3026 </span></a> 
3047 <a name="l3027"><span class="ln">3027 </span></a>    The results from a successful parse will contain the matched text 
3048 <a name="l3028"><span class="ln">3028 </span></a>    from the input string and the following named results: 
3049 <a name="l3029"><span class="ln">3029 </span></a> 
3050 <a name="l3030"><span class="ln">3030 </span></a>     - ``mismatches`` - a list of the positions within the 
3051 <a name="l3031"><span class="ln">3031 </span></a>       match_string where mismatches were found 
3052 <a name="l3032"><span class="ln">3032 </span></a>     - ``original`` - the original match_string used to compare 
3053 <a name="l3033"><span class="ln">3033 </span></a>       against the input string 
3054 <a name="l3034"><span class="ln">3034 </span></a> 
3055 <a name="l3035"><span class="ln">3035 </span></a>    If ``mismatches`` is an empty list, then the match was an exact 
3056 <a name="l3036"><span class="ln">3036 </span></a>    match. 
3057 <a name="l3037"><span class="ln">3037 </span></a> 
3058 <a name="l3038"><span class="ln">3038 </span></a>    Example:: 
3059 <a name="l3039"><span class="ln">3039 </span></a> 
3060 <a name="l3040"><span class="ln">3040 </span></a>        patt = CloseMatch(&quot;ATCATCGAATGGA&quot;) 
3061 <a name="l3041"><span class="ln">3041 </span></a>        patt.parseString(&quot;ATCATCGAAXGGA&quot;) # -&gt; (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']}) 
3062 <a name="l3042"><span class="ln">3042 </span></a>        patt.parseString(&quot;ATCAXCGAAXGGA&quot;) # -&gt; Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1) 
3063 <a name="l3043"><span class="ln">3043 </span></a> 
3064 <a name="l3044"><span class="ln">3044 </span></a>        # exact match 
3065 <a name="l3045"><span class="ln">3045 </span></a>        patt.parseString(&quot;ATCATCGAATGGA&quot;) # -&gt; (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']}) 
3066 <a name="l3046"><span class="ln">3046 </span></a> 
3067 <a name="l3047"><span class="ln">3047 </span></a>        # close match allowing up to 2 mismatches 
3068 <a name="l3048"><span class="ln">3048 </span></a>        patt = CloseMatch(&quot;ATCATCGAATGGA&quot;, maxMismatches=2) 
3069 <a name="l3049"><span class="ln">3049 </span></a>        patt.parseString(&quot;ATCAXCGAAXGGA&quot;) # -&gt; (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']}) 
3070 <a name="l3050"><span class="ln">3050 </span></a>    &quot;&quot;&quot;</span>
3071 <a name="l3051"><span class="ln">3051 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">match_string</span><span class="s3">, </span><span class="s1">maxMismatches=</span><span class="s4">1</span><span class="s1">):</span>
3072 <a name="l3052"><span class="ln">3052 </span></a>        <span class="s1">super(CloseMatch</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3073 <a name="l3053"><span class="ln">3053 </span></a>        <span class="s1">self.name = match_string</span>
3074 <a name="l3054"><span class="ln">3054 </span></a>        <span class="s1">self.match_string = match_string</span>
3075 <a name="l3055"><span class="ln">3055 </span></a>        <span class="s1">self.maxMismatches = maxMismatches</span>
3076 <a name="l3056"><span class="ln">3056 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected %r (with up to %d mismatches)&quot; </span><span class="s1">% (self.match_string</span><span class="s3">, </span><span class="s1">self.maxMismatches)</span>
3077 <a name="l3057"><span class="ln">3057 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
3078 <a name="l3058"><span class="ln">3058 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">False</span>
3079 <a name="l3059"><span class="ln">3059 </span></a>
3080 <a name="l3060"><span class="ln">3060 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3081 <a name="l3061"><span class="ln">3061 </span></a>        <span class="s1">start = loc</span>
3082 <a name="l3062"><span class="ln">3062 </span></a>        <span class="s1">instrlen = len(instring)</span>
3083 <a name="l3063"><span class="ln">3063 </span></a>        <span class="s1">maxloc = start + len(self.match_string)</span>
3084 <a name="l3064"><span class="ln">3064 </span></a>
3085 <a name="l3065"><span class="ln">3065 </span></a>        <span class="s3">if </span><span class="s1">maxloc &lt;= instrlen:</span>
3086 <a name="l3066"><span class="ln">3066 </span></a>            <span class="s1">match_string = self.match_string</span>
3087 <a name="l3067"><span class="ln">3067 </span></a>            <span class="s1">match_stringloc = </span><span class="s4">0</span>
3088 <a name="l3068"><span class="ln">3068 </span></a>            <span class="s1">mismatches = []</span>
3089 <a name="l3069"><span class="ln">3069 </span></a>            <span class="s1">maxMismatches = self.maxMismatches</span>
3090 <a name="l3070"><span class="ln">3070 </span></a>
3091 <a name="l3071"><span class="ln">3071 </span></a>            <span class="s3">for </span><span class="s1">match_stringloc</span><span class="s3">, </span><span class="s1">s_m </span><span class="s3">in </span><span class="s1">enumerate(zip(instring[loc:maxloc]</span><span class="s3">, </span><span class="s1">match_string)):</span>
3092 <a name="l3072"><span class="ln">3072 </span></a>                <span class="s1">src</span><span class="s3">, </span><span class="s1">mat = s_m</span>
3093 <a name="l3073"><span class="ln">3073 </span></a>                <span class="s3">if </span><span class="s1">src != mat:</span>
3094 <a name="l3074"><span class="ln">3074 </span></a>                    <span class="s1">mismatches.append(match_stringloc)</span>
3095 <a name="l3075"><span class="ln">3075 </span></a>                    <span class="s3">if </span><span class="s1">len(mismatches) &gt; maxMismatches:</span>
3096 <a name="l3076"><span class="ln">3076 </span></a>                        <span class="s3">break</span>
3097 <a name="l3077"><span class="ln">3077 </span></a>            <span class="s3">else</span><span class="s1">:</span>
3098 <a name="l3078"><span class="ln">3078 </span></a>                <span class="s1">loc = match_stringloc + </span><span class="s4">1</span>
3099 <a name="l3079"><span class="ln">3079 </span></a>                <span class="s1">results = ParseResults([instring[start:loc]])</span>
3100 <a name="l3080"><span class="ln">3080 </span></a>                <span class="s1">results[</span><span class="s2">'original'</span><span class="s1">] = match_string</span>
3101 <a name="l3081"><span class="ln">3081 </span></a>                <span class="s1">results[</span><span class="s2">'mismatches'</span><span class="s1">] = mismatches</span>
3102 <a name="l3082"><span class="ln">3082 </span></a>                <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">results</span>
3103 <a name="l3083"><span class="ln">3083 </span></a>
3104 <a name="l3084"><span class="ln">3084 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3105 <a name="l3085"><span class="ln">3085 </span></a>
3106 <a name="l3086"><span class="ln">3086 </span></a>
3107 <a name="l3087"><span class="ln">3087 </span></a><span class="s3">class </span><span class="s1">Word(Token):</span>
3108 <a name="l3088"><span class="ln">3088 </span></a>    <span class="s5">&quot;&quot;&quot;Token for matching words composed of allowed character sets. 
3109 <a name="l3089"><span class="ln">3089 </span></a>    Defined with string containing all allowed initial characters, an 
3110 <a name="l3090"><span class="ln">3090 </span></a>    optional string containing allowed body characters (if omitted, 
3111 <a name="l3091"><span class="ln">3091 </span></a>    defaults to the initial character set), and an optional minimum, 
3112 <a name="l3092"><span class="ln">3092 </span></a>    maximum, and/or exact length.  The default value for ``min`` is 
3113 <a name="l3093"><span class="ln">3093 </span></a>    1 (a minimum value &lt; 1 is not valid); the default values for 
3114 <a name="l3094"><span class="ln">3094 </span></a>    ``max`` and ``exact`` are 0, meaning no maximum or exact 
3115 <a name="l3095"><span class="ln">3095 </span></a>    length restriction. An optional ``excludeChars`` parameter can 
3116 <a name="l3096"><span class="ln">3096 </span></a>    list characters that might be found in the input ``bodyChars`` 
3117 <a name="l3097"><span class="ln">3097 </span></a>    string; useful to define a word of all printables except for one or 
3118 <a name="l3098"><span class="ln">3098 </span></a>    two characters, for instance. 
3119 <a name="l3099"><span class="ln">3099 </span></a> 
3120 <a name="l3100"><span class="ln">3100 </span></a>    :class:`srange` is useful for defining custom character set strings 
3121 <a name="l3101"><span class="ln">3101 </span></a>    for defining ``Word`` expressions, using range notation from 
3122 <a name="l3102"><span class="ln">3102 </span></a>    regular expression character sets. 
3123 <a name="l3103"><span class="ln">3103 </span></a> 
3124 <a name="l3104"><span class="ln">3104 </span></a>    A common mistake is to use :class:`Word` to match a specific literal 
3125 <a name="l3105"><span class="ln">3105 </span></a>    string, as in ``Word(&quot;Address&quot;)``. Remember that :class:`Word` 
3126 <a name="l3106"><span class="ln">3106 </span></a>    uses the string argument to define *sets* of matchable characters. 
3127 <a name="l3107"><span class="ln">3107 </span></a>    This expression would match &quot;Add&quot;, &quot;AAA&quot;, &quot;dAred&quot;, or any other word 
3128 <a name="l3108"><span class="ln">3108 </span></a>    made up of the characters 'A', 'd', 'r', 'e', and 's'. To match an 
3129 <a name="l3109"><span class="ln">3109 </span></a>    exact literal string, use :class:`Literal` or :class:`Keyword`. 
3130 <a name="l3110"><span class="ln">3110 </span></a> 
3131 <a name="l3111"><span class="ln">3111 </span></a>    pyparsing includes helper strings for building Words: 
3132 <a name="l3112"><span class="ln">3112 </span></a> 
3133 <a name="l3113"><span class="ln">3113 </span></a>     - :class:`alphas` 
3134 <a name="l3114"><span class="ln">3114 </span></a>     - :class:`nums` 
3135 <a name="l3115"><span class="ln">3115 </span></a>     - :class:`alphanums` 
3136 <a name="l3116"><span class="ln">3116 </span></a>     - :class:`hexnums` 
3137 <a name="l3117"><span class="ln">3117 </span></a>     - :class:`alphas8bit` (alphabetic characters in ASCII range 128-255 
3138 <a name="l3118"><span class="ln">3118 </span></a>       - accented, tilded, umlauted, etc.) 
3139 <a name="l3119"><span class="ln">3119 </span></a>     - :class:`punc8bit` (non-alphabetic characters in ASCII range 
3140 <a name="l3120"><span class="ln">3120 </span></a>       128-255 - currency, symbols, superscripts, diacriticals, etc.) 
3141 <a name="l3121"><span class="ln">3121 </span></a>     - :class:`printables` (any non-whitespace character) 
3142 <a name="l3122"><span class="ln">3122 </span></a> 
3143 <a name="l3123"><span class="ln">3123 </span></a>    Example:: 
3144 <a name="l3124"><span class="ln">3124 </span></a> 
3145 <a name="l3125"><span class="ln">3125 </span></a>        # a word composed of digits 
3146 <a name="l3126"><span class="ln">3126 </span></a>        integer = Word(nums) # equivalent to Word(&quot;0123456789&quot;) or Word(srange(&quot;0-9&quot;)) 
3147 <a name="l3127"><span class="ln">3127 </span></a> 
3148 <a name="l3128"><span class="ln">3128 </span></a>        # a word with a leading capital, and zero or more lowercase 
3149 <a name="l3129"><span class="ln">3129 </span></a>        capital_word = Word(alphas.upper(), alphas.lower()) 
3150 <a name="l3130"><span class="ln">3130 </span></a> 
3151 <a name="l3131"><span class="ln">3131 </span></a>        # hostnames are alphanumeric, with leading alpha, and '-' 
3152 <a name="l3132"><span class="ln">3132 </span></a>        hostname = Word(alphas, alphanums + '-') 
3153 <a name="l3133"><span class="ln">3133 </span></a> 
3154 <a name="l3134"><span class="ln">3134 </span></a>        # roman numeral (not a strict parser, accepts invalid mix of characters) 
3155 <a name="l3135"><span class="ln">3135 </span></a>        roman = Word(&quot;IVXLCDM&quot;) 
3156 <a name="l3136"><span class="ln">3136 </span></a> 
3157 <a name="l3137"><span class="ln">3137 </span></a>        # any string of non-whitespace characters, except for ',' 
3158 <a name="l3138"><span class="ln">3138 </span></a>        csv_value = Word(printables, excludeChars=&quot;,&quot;) 
3159 <a name="l3139"><span class="ln">3139 </span></a>    &quot;&quot;&quot;</span>
3160 <a name="l3140"><span class="ln">3140 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">initChars</span><span class="s3">, </span><span class="s1">bodyChars=</span><span class="s3">None, </span><span class="s1">min=</span><span class="s4">1</span><span class="s3">, </span><span class="s1">max=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">asKeyword=</span><span class="s3">False, </span><span class="s1">excludeChars=</span><span class="s3">None</span><span class="s1">):</span>
3161 <a name="l3141"><span class="ln">3141 </span></a>        <span class="s1">super(Word</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3162 <a name="l3142"><span class="ln">3142 </span></a>        <span class="s3">if </span><span class="s1">excludeChars:</span>
3163 <a name="l3143"><span class="ln">3143 </span></a>            <span class="s1">excludeChars = set(excludeChars)</span>
3164 <a name="l3144"><span class="ln">3144 </span></a>            <span class="s1">initChars = </span><span class="s2">''</span><span class="s1">.join(c </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">initChars </span><span class="s3">if </span><span class="s1">c </span><span class="s3">not in </span><span class="s1">excludeChars)</span>
3165 <a name="l3145"><span class="ln">3145 </span></a>            <span class="s3">if </span><span class="s1">bodyChars:</span>
3166 <a name="l3146"><span class="ln">3146 </span></a>                <span class="s1">bodyChars = </span><span class="s2">''</span><span class="s1">.join(c </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">bodyChars </span><span class="s3">if </span><span class="s1">c </span><span class="s3">not in </span><span class="s1">excludeChars)</span>
3167 <a name="l3147"><span class="ln">3147 </span></a>        <span class="s1">self.initCharsOrig = initChars</span>
3168 <a name="l3148"><span class="ln">3148 </span></a>        <span class="s1">self.initChars = set(initChars)</span>
3169 <a name="l3149"><span class="ln">3149 </span></a>        <span class="s3">if </span><span class="s1">bodyChars:</span>
3170 <a name="l3150"><span class="ln">3150 </span></a>            <span class="s1">self.bodyCharsOrig = bodyChars</span>
3171 <a name="l3151"><span class="ln">3151 </span></a>            <span class="s1">self.bodyChars = set(bodyChars)</span>
3172 <a name="l3152"><span class="ln">3152 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3173 <a name="l3153"><span class="ln">3153 </span></a>            <span class="s1">self.bodyCharsOrig = initChars</span>
3174 <a name="l3154"><span class="ln">3154 </span></a>            <span class="s1">self.bodyChars = set(initChars)</span>
3175 <a name="l3155"><span class="ln">3155 </span></a>
3176 <a name="l3156"><span class="ln">3156 </span></a>        <span class="s1">self.maxSpecified = max &gt; </span><span class="s4">0</span>
3177 <a name="l3157"><span class="ln">3157 </span></a>
3178 <a name="l3158"><span class="ln">3158 </span></a>        <span class="s3">if </span><span class="s1">min &lt; </span><span class="s4">1</span><span class="s1">:</span>
3179 <a name="l3159"><span class="ln">3159 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;cannot specify a minimum length &lt; 1; use Optional(Word()) if zero-length word is permitted&quot;</span><span class="s1">)</span>
3180 <a name="l3160"><span class="ln">3160 </span></a>
3181 <a name="l3161"><span class="ln">3161 </span></a>        <span class="s1">self.minLen = min</span>
3182 <a name="l3162"><span class="ln">3162 </span></a>
3183 <a name="l3163"><span class="ln">3163 </span></a>        <span class="s3">if </span><span class="s1">max &gt; </span><span class="s4">0</span><span class="s1">:</span>
3184 <a name="l3164"><span class="ln">3164 </span></a>            <span class="s1">self.maxLen = max</span>
3185 <a name="l3165"><span class="ln">3165 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3186 <a name="l3166"><span class="ln">3166 </span></a>            <span class="s1">self.maxLen = _MAX_INT</span>
3187 <a name="l3167"><span class="ln">3167 </span></a>
3188 <a name="l3168"><span class="ln">3168 </span></a>        <span class="s3">if </span><span class="s1">exact &gt; </span><span class="s4">0</span><span class="s1">:</span>
3189 <a name="l3169"><span class="ln">3169 </span></a>            <span class="s1">self.maxLen = exact</span>
3190 <a name="l3170"><span class="ln">3170 </span></a>            <span class="s1">self.minLen = exact</span>
3191 <a name="l3171"><span class="ln">3171 </span></a>
3192 <a name="l3172"><span class="ln">3172 </span></a>        <span class="s1">self.name = _ustr(self)</span>
3193 <a name="l3173"><span class="ln">3173 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
3194 <a name="l3174"><span class="ln">3174 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
3195 <a name="l3175"><span class="ln">3175 </span></a>        <span class="s1">self.asKeyword = asKeyword</span>
3196 <a name="l3176"><span class="ln">3176 </span></a>
3197 <a name="l3177"><span class="ln">3177 </span></a>        <span class="s3">if </span><span class="s2">' ' </span><span class="s3">not in </span><span class="s1">self.initCharsOrig + self.bodyCharsOrig </span><span class="s3">and </span><span class="s1">(min == </span><span class="s4">1 </span><span class="s3">and </span><span class="s1">max == </span><span class="s4">0 </span><span class="s3">and </span><span class="s1">exact == </span><span class="s4">0</span><span class="s1">):</span>
3198 <a name="l3178"><span class="ln">3178 </span></a>            <span class="s3">if </span><span class="s1">self.bodyCharsOrig == self.initCharsOrig:</span>
3199 <a name="l3179"><span class="ln">3179 </span></a>                <span class="s1">self.reString = </span><span class="s2">&quot;[%s]+&quot; </span><span class="s1">% _escapeRegexRangeChars(self.initCharsOrig)</span>
3200 <a name="l3180"><span class="ln">3180 </span></a>            <span class="s3">elif </span><span class="s1">len(self.initCharsOrig) == </span><span class="s4">1</span><span class="s1">:</span>
3201 <a name="l3181"><span class="ln">3181 </span></a>                <span class="s1">self.reString = </span><span class="s2">&quot;%s[%s]*&quot; </span><span class="s1">% (re.escape(self.initCharsOrig)</span><span class="s3">,</span>
3202 <a name="l3182"><span class="ln">3182 </span></a>                                             <span class="s1">_escapeRegexRangeChars(self.bodyCharsOrig)</span><span class="s3">,</span><span class="s1">)</span>
3203 <a name="l3183"><span class="ln">3183 </span></a>            <span class="s3">else</span><span class="s1">:</span>
3204 <a name="l3184"><span class="ln">3184 </span></a>                <span class="s1">self.reString = </span><span class="s2">&quot;[%s][%s]*&quot; </span><span class="s1">% (_escapeRegexRangeChars(self.initCharsOrig)</span><span class="s3">,</span>
3205 <a name="l3185"><span class="ln">3185 </span></a>                                               <span class="s1">_escapeRegexRangeChars(self.bodyCharsOrig)</span><span class="s3">,</span><span class="s1">)</span>
3206 <a name="l3186"><span class="ln">3186 </span></a>            <span class="s3">if </span><span class="s1">self.asKeyword:</span>
3207 <a name="l3187"><span class="ln">3187 </span></a>                <span class="s1">self.reString = </span><span class="s2">r&quot;\b&quot; </span><span class="s1">+ self.reString + </span><span class="s2">r&quot;\b&quot;</span>
3208 <a name="l3188"><span class="ln">3188 </span></a>
3209 <a name="l3189"><span class="ln">3189 </span></a>            <span class="s3">try</span><span class="s1">:</span>
3210 <a name="l3190"><span class="ln">3190 </span></a>                <span class="s1">self.re = re.compile(self.reString)</span>
3211 <a name="l3191"><span class="ln">3191 </span></a>            <span class="s3">except </span><span class="s1">Exception:</span>
3212 <a name="l3192"><span class="ln">3192 </span></a>                <span class="s1">self.re = </span><span class="s3">None</span>
3213 <a name="l3193"><span class="ln">3193 </span></a>            <span class="s3">else</span><span class="s1">:</span>
3214 <a name="l3194"><span class="ln">3194 </span></a>                <span class="s1">self.re_match = self.re.match</span>
3215 <a name="l3195"><span class="ln">3195 </span></a>                <span class="s1">self.__class__ = _WordRegex</span>
3216 <a name="l3196"><span class="ln">3196 </span></a>
3217 <a name="l3197"><span class="ln">3197 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3218 <a name="l3198"><span class="ln">3198 </span></a>        <span class="s3">if </span><span class="s1">instring[loc] </span><span class="s3">not in </span><span class="s1">self.initChars:</span>
3219 <a name="l3199"><span class="ln">3199 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3220 <a name="l3200"><span class="ln">3200 </span></a>
3221 <a name="l3201"><span class="ln">3201 </span></a>        <span class="s1">start = loc</span>
3222 <a name="l3202"><span class="ln">3202 </span></a>        <span class="s1">loc += </span><span class="s4">1</span>
3223 <a name="l3203"><span class="ln">3203 </span></a>        <span class="s1">instrlen = len(instring)</span>
3224 <a name="l3204"><span class="ln">3204 </span></a>        <span class="s1">bodychars = self.bodyChars</span>
3225 <a name="l3205"><span class="ln">3205 </span></a>        <span class="s1">maxloc = start + self.maxLen</span>
3226 <a name="l3206"><span class="ln">3206 </span></a>        <span class="s1">maxloc = min(maxloc</span><span class="s3">, </span><span class="s1">instrlen)</span>
3227 <a name="l3207"><span class="ln">3207 </span></a>        <span class="s3">while </span><span class="s1">loc &lt; maxloc </span><span class="s3">and </span><span class="s1">instring[loc] </span><span class="s3">in </span><span class="s1">bodychars:</span>
3228 <a name="l3208"><span class="ln">3208 </span></a>            <span class="s1">loc += </span><span class="s4">1</span>
3229 <a name="l3209"><span class="ln">3209 </span></a>
3230 <a name="l3210"><span class="ln">3210 </span></a>        <span class="s1">throwException = </span><span class="s3">False</span>
3231 <a name="l3211"><span class="ln">3211 </span></a>        <span class="s3">if </span><span class="s1">loc - start &lt; self.minLen:</span>
3232 <a name="l3212"><span class="ln">3212 </span></a>            <span class="s1">throwException = </span><span class="s3">True</span>
3233 <a name="l3213"><span class="ln">3213 </span></a>        <span class="s3">elif </span><span class="s1">self.maxSpecified </span><span class="s3">and </span><span class="s1">loc &lt; instrlen </span><span class="s3">and </span><span class="s1">instring[loc] </span><span class="s3">in </span><span class="s1">bodychars:</span>
3234 <a name="l3214"><span class="ln">3214 </span></a>            <span class="s1">throwException = </span><span class="s3">True</span>
3235 <a name="l3215"><span class="ln">3215 </span></a>        <span class="s3">elif </span><span class="s1">self.asKeyword:</span>
3236 <a name="l3216"><span class="ln">3216 </span></a>            <span class="s3">if </span><span class="s1">(start &gt; </span><span class="s4">0 </span><span class="s3">and </span><span class="s1">instring[start - </span><span class="s4">1</span><span class="s1">] </span><span class="s3">in </span><span class="s1">bodychars</span>
3237 <a name="l3217"><span class="ln">3217 </span></a>                    <span class="s3">or </span><span class="s1">loc &lt; instrlen </span><span class="s3">and </span><span class="s1">instring[loc] </span><span class="s3">in </span><span class="s1">bodychars):</span>
3238 <a name="l3218"><span class="ln">3218 </span></a>                <span class="s1">throwException = </span><span class="s3">True</span>
3239 <a name="l3219"><span class="ln">3219 </span></a>
3240 <a name="l3220"><span class="ln">3220 </span></a>        <span class="s3">if </span><span class="s1">throwException:</span>
3241 <a name="l3221"><span class="ln">3221 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3242 <a name="l3222"><span class="ln">3222 </span></a>
3243 <a name="l3223"><span class="ln">3223 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">instring[start:loc]</span>
3244 <a name="l3224"><span class="ln">3224 </span></a>
3245 <a name="l3225"><span class="ln">3225 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
3246 <a name="l3226"><span class="ln">3226 </span></a>        <span class="s3">try</span><span class="s1">:</span>
3247 <a name="l3227"><span class="ln">3227 </span></a>            <span class="s3">return </span><span class="s1">super(Word</span><span class="s3">, </span><span class="s1">self).__str__()</span>
3248 <a name="l3228"><span class="ln">3228 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
3249 <a name="l3229"><span class="ln">3229 </span></a>            <span class="s3">pass</span>
3250 <a name="l3230"><span class="ln">3230 </span></a>
3251 <a name="l3231"><span class="ln">3231 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
3252 <a name="l3232"><span class="ln">3232 </span></a>
3253 <a name="l3233"><span class="ln">3233 </span></a>            <span class="s3">def </span><span class="s1">charsAsStr(s):</span>
3254 <a name="l3234"><span class="ln">3234 </span></a>                <span class="s3">if </span><span class="s1">len(s) &gt; </span><span class="s4">4</span><span class="s1">:</span>
3255 <a name="l3235"><span class="ln">3235 </span></a>                    <span class="s3">return </span><span class="s1">s[:</span><span class="s4">4</span><span class="s1">] + </span><span class="s2">&quot;...&quot;</span>
3256 <a name="l3236"><span class="ln">3236 </span></a>                <span class="s3">else</span><span class="s1">:</span>
3257 <a name="l3237"><span class="ln">3237 </span></a>                    <span class="s3">return </span><span class="s1">s</span>
3258 <a name="l3238"><span class="ln">3238 </span></a>
3259 <a name="l3239"><span class="ln">3239 </span></a>            <span class="s3">if </span><span class="s1">self.initCharsOrig != self.bodyCharsOrig:</span>
3260 <a name="l3240"><span class="ln">3240 </span></a>                <span class="s1">self.strRepr = </span><span class="s2">&quot;W:(%s, %s)&quot; </span><span class="s1">% (charsAsStr(self.initCharsOrig)</span><span class="s3">, </span><span class="s1">charsAsStr(self.bodyCharsOrig))</span>
3261 <a name="l3241"><span class="ln">3241 </span></a>            <span class="s3">else</span><span class="s1">:</span>
3262 <a name="l3242"><span class="ln">3242 </span></a>                <span class="s1">self.strRepr = </span><span class="s2">&quot;W:(%s)&quot; </span><span class="s1">% charsAsStr(self.initCharsOrig)</span>
3263 <a name="l3243"><span class="ln">3243 </span></a>
3264 <a name="l3244"><span class="ln">3244 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
3265 <a name="l3245"><span class="ln">3245 </span></a>
3266 <a name="l3246"><span class="ln">3246 </span></a><span class="s3">class </span><span class="s1">_WordRegex(Word):</span>
3267 <a name="l3247"><span class="ln">3247 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3268 <a name="l3248"><span class="ln">3248 </span></a>        <span class="s1">result = self.re_match(instring</span><span class="s3">, </span><span class="s1">loc)</span>
3269 <a name="l3249"><span class="ln">3249 </span></a>        <span class="s3">if not </span><span class="s1">result:</span>
3270 <a name="l3250"><span class="ln">3250 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3271 <a name="l3251"><span class="ln">3251 </span></a>
3272 <a name="l3252"><span class="ln">3252 </span></a>        <span class="s1">loc = result.end()</span>
3273 <a name="l3253"><span class="ln">3253 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">result.group()</span>
3274 <a name="l3254"><span class="ln">3254 </span></a>
3275 <a name="l3255"><span class="ln">3255 </span></a>
3276 <a name="l3256"><span class="ln">3256 </span></a><span class="s3">class </span><span class="s1">Char(_WordRegex):</span>
3277 <a name="l3257"><span class="ln">3257 </span></a>    <span class="s5">&quot;&quot;&quot;A short-cut class for defining ``Word(characters, exact=1)``, 
3278 <a name="l3258"><span class="ln">3258 </span></a>    when defining a match of any single character in a string of 
3279 <a name="l3259"><span class="ln">3259 </span></a>    characters. 
3280 <a name="l3260"><span class="ln">3260 </span></a>    &quot;&quot;&quot;</span>
3281 <a name="l3261"><span class="ln">3261 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">charset</span><span class="s3">, </span><span class="s1">asKeyword=</span><span class="s3">False, </span><span class="s1">excludeChars=</span><span class="s3">None</span><span class="s1">):</span>
3282 <a name="l3262"><span class="ln">3262 </span></a>        <span class="s1">super(Char</span><span class="s3">, </span><span class="s1">self).__init__(charset</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">1</span><span class="s3">, </span><span class="s1">asKeyword=asKeyword</span><span class="s3">, </span><span class="s1">excludeChars=excludeChars)</span>
3283 <a name="l3263"><span class="ln">3263 </span></a>        <span class="s1">self.reString = </span><span class="s2">&quot;[%s]&quot; </span><span class="s1">% _escapeRegexRangeChars(</span><span class="s2">''</span><span class="s1">.join(self.initChars))</span>
3284 <a name="l3264"><span class="ln">3264 </span></a>        <span class="s3">if </span><span class="s1">asKeyword:</span>
3285 <a name="l3265"><span class="ln">3265 </span></a>            <span class="s1">self.reString = </span><span class="s2">r&quot;\b%s\b&quot; </span><span class="s1">% self.reString</span>
3286 <a name="l3266"><span class="ln">3266 </span></a>        <span class="s1">self.re = re.compile(self.reString)</span>
3287 <a name="l3267"><span class="ln">3267 </span></a>        <span class="s1">self.re_match = self.re.match</span>
3288 <a name="l3268"><span class="ln">3268 </span></a>
3289 <a name="l3269"><span class="ln">3269 </span></a>
3290 <a name="l3270"><span class="ln">3270 </span></a><span class="s3">class </span><span class="s1">Regex(Token):</span>
3291 <a name="l3271"><span class="ln">3271 </span></a>    <span class="s5">r&quot;&quot;&quot;Token for matching strings that match a given regular 
3292 <a name="l3272"><span class="ln">3272 </span></a>    expression. Defined with string specifying the regular expression in 
3293 <a name="l3273"><span class="ln">3273 </span></a>    a form recognized by the stdlib Python  `re module &lt;https://docs.python.org/3/library/re.html&gt;`_. 
3294 <a name="l3274"><span class="ln">3274 </span></a>    If the given regex contains named groups (defined using ``(?P&lt;name&gt;...)``), 
3295 <a name="l3275"><span class="ln">3275 </span></a>    these will be preserved as named parse results. 
3296 <a name="l3276"><span class="ln">3276 </span></a> 
3297 <a name="l3277"><span class="ln">3277 </span></a>    If instead of the Python stdlib re module you wish to use a different RE module 
3298 <a name="l3278"><span class="ln">3278 </span></a>    (such as the `regex` module), you can replace it by either building your 
3299 <a name="l3279"><span class="ln">3279 </span></a>    Regex object with a compiled RE that was compiled using regex: 
3300 <a name="l3280"><span class="ln">3280 </span></a> 
3301 <a name="l3281"><span class="ln">3281 </span></a>    Example:: 
3302 <a name="l3282"><span class="ln">3282 </span></a> 
3303 <a name="l3283"><span class="ln">3283 </span></a>        realnum = Regex(r&quot;[+-]?\d+\.\d*&quot;) 
3304 <a name="l3284"><span class="ln">3284 </span></a>        date = Regex(r'(?P&lt;year&gt;\d{4})-(?P&lt;month&gt;\d\d?)-(?P&lt;day&gt;\d\d?)') 
3305 <a name="l3285"><span class="ln">3285 </span></a>        # ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression 
3306 <a name="l3286"><span class="ln">3286 </span></a>        roman = Regex(r&quot;M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})&quot;) 
3307 <a name="l3287"><span class="ln">3287 </span></a> 
3308 <a name="l3288"><span class="ln">3288 </span></a>        # use regex module instead of stdlib re module to construct a Regex using 
3309 <a name="l3289"><span class="ln">3289 </span></a>        # a compiled regular expression 
3310 <a name="l3290"><span class="ln">3290 </span></a>        import regex 
3311 <a name="l3291"><span class="ln">3291 </span></a>        parser = pp.Regex(regex.compile(r'[0-9]')) 
3312 <a name="l3292"><span class="ln">3292 </span></a> 
3313 <a name="l3293"><span class="ln">3293 </span></a>    &quot;&quot;&quot;</span>
3314 <a name="l3294"><span class="ln">3294 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">pattern</span><span class="s3">, </span><span class="s1">flags=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">asGroupList=</span><span class="s3">False, </span><span class="s1">asMatch=</span><span class="s3">False</span><span class="s1">):</span>
3315 <a name="l3295"><span class="ln">3295 </span></a>        <span class="s5">&quot;&quot;&quot;The parameters ``pattern`` and ``flags`` are passed 
3316 <a name="l3296"><span class="ln">3296 </span></a>        to the ``re.compile()`` function as-is. See the Python 
3317 <a name="l3297"><span class="ln">3297 </span></a>        `re module &lt;https://docs.python.org/3/library/re.html&gt;`_ module for an 
3318 <a name="l3298"><span class="ln">3298 </span></a>        explanation of the acceptable patterns and flags. 
3319 <a name="l3299"><span class="ln">3299 </span></a>        &quot;&quot;&quot;</span>
3320 <a name="l3300"><span class="ln">3300 </span></a>        <span class="s1">super(Regex</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3321 <a name="l3301"><span class="ln">3301 </span></a>
3322 <a name="l3302"><span class="ln">3302 </span></a>        <span class="s3">if </span><span class="s1">isinstance(pattern</span><span class="s3">, </span><span class="s1">basestring):</span>
3323 <a name="l3303"><span class="ln">3303 </span></a>            <span class="s3">if not </span><span class="s1">pattern:</span>
3324 <a name="l3304"><span class="ln">3304 </span></a>                <span class="s1">warnings.warn(</span><span class="s2">&quot;null string passed to Regex; use Empty() instead&quot;</span><span class="s3">,</span>
3325 <a name="l3305"><span class="ln">3305 </span></a>                              <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3326 <a name="l3306"><span class="ln">3306 </span></a>
3327 <a name="l3307"><span class="ln">3307 </span></a>            <span class="s1">self.pattern = pattern</span>
3328 <a name="l3308"><span class="ln">3308 </span></a>            <span class="s1">self.flags = flags</span>
3329 <a name="l3309"><span class="ln">3309 </span></a>
3330 <a name="l3310"><span class="ln">3310 </span></a>            <span class="s3">try</span><span class="s1">:</span>
3331 <a name="l3311"><span class="ln">3311 </span></a>                <span class="s1">self.re = re.compile(self.pattern</span><span class="s3">, </span><span class="s1">self.flags)</span>
3332 <a name="l3312"><span class="ln">3312 </span></a>                <span class="s1">self.reString = self.pattern</span>
3333 <a name="l3313"><span class="ln">3313 </span></a>            <span class="s3">except </span><span class="s1">sre_constants.error:</span>
3334 <a name="l3314"><span class="ln">3314 </span></a>                <span class="s1">warnings.warn(</span><span class="s2">&quot;invalid pattern (%s) passed to Regex&quot; </span><span class="s1">% pattern</span><span class="s3">,</span>
3335 <a name="l3315"><span class="ln">3315 </span></a>                              <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3336 <a name="l3316"><span class="ln">3316 </span></a>                <span class="s3">raise</span>
3337 <a name="l3317"><span class="ln">3317 </span></a>
3338 <a name="l3318"><span class="ln">3318 </span></a>        <span class="s3">elif </span><span class="s1">hasattr(pattern</span><span class="s3">, </span><span class="s2">'pattern'</span><span class="s1">) </span><span class="s3">and </span><span class="s1">hasattr(pattern</span><span class="s3">, </span><span class="s2">'match'</span><span class="s1">):</span>
3339 <a name="l3319"><span class="ln">3319 </span></a>            <span class="s1">self.re = pattern</span>
3340 <a name="l3320"><span class="ln">3320 </span></a>            <span class="s1">self.pattern = self.reString = pattern.pattern</span>
3341 <a name="l3321"><span class="ln">3321 </span></a>            <span class="s1">self.flags = flags</span>
3342 <a name="l3322"><span class="ln">3322 </span></a>
3343 <a name="l3323"><span class="ln">3323 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3344 <a name="l3324"><span class="ln">3324 </span></a>            <span class="s3">raise </span><span class="s1">TypeError(</span><span class="s2">&quot;Regex may only be constructed with a string or a compiled RE object&quot;</span><span class="s1">)</span>
3345 <a name="l3325"><span class="ln">3325 </span></a>
3346 <a name="l3326"><span class="ln">3326 </span></a>        <span class="s1">self.re_match = self.re.match</span>
3347 <a name="l3327"><span class="ln">3327 </span></a>
3348 <a name="l3328"><span class="ln">3328 </span></a>        <span class="s1">self.name = _ustr(self)</span>
3349 <a name="l3329"><span class="ln">3329 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
3350 <a name="l3330"><span class="ln">3330 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
3351 <a name="l3331"><span class="ln">3331 </span></a>        <span class="s1">self.mayReturnEmpty = self.re_match(</span><span class="s2">&quot;&quot;</span><span class="s1">) </span><span class="s3">is not None</span>
3352 <a name="l3332"><span class="ln">3332 </span></a>        <span class="s1">self.asGroupList = asGroupList</span>
3353 <a name="l3333"><span class="ln">3333 </span></a>        <span class="s1">self.asMatch = asMatch</span>
3354 <a name="l3334"><span class="ln">3334 </span></a>        <span class="s3">if </span><span class="s1">self.asGroupList:</span>
3355 <a name="l3335"><span class="ln">3335 </span></a>            <span class="s1">self.parseImpl = self.parseImplAsGroupList</span>
3356 <a name="l3336"><span class="ln">3336 </span></a>        <span class="s3">if </span><span class="s1">self.asMatch:</span>
3357 <a name="l3337"><span class="ln">3337 </span></a>            <span class="s1">self.parseImpl = self.parseImplAsMatch</span>
3358 <a name="l3338"><span class="ln">3338 </span></a>
3359 <a name="l3339"><span class="ln">3339 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3360 <a name="l3340"><span class="ln">3340 </span></a>        <span class="s1">result = self.re_match(instring</span><span class="s3">, </span><span class="s1">loc)</span>
3361 <a name="l3341"><span class="ln">3341 </span></a>        <span class="s3">if not </span><span class="s1">result:</span>
3362 <a name="l3342"><span class="ln">3342 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3363 <a name="l3343"><span class="ln">3343 </span></a>
3364 <a name="l3344"><span class="ln">3344 </span></a>        <span class="s1">loc = result.end()</span>
3365 <a name="l3345"><span class="ln">3345 </span></a>        <span class="s1">ret = ParseResults(result.group())</span>
3366 <a name="l3346"><span class="ln">3346 </span></a>        <span class="s1">d = result.groupdict()</span>
3367 <a name="l3347"><span class="ln">3347 </span></a>        <span class="s3">if </span><span class="s1">d:</span>
3368 <a name="l3348"><span class="ln">3348 </span></a>            <span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">d.items():</span>
3369 <a name="l3349"><span class="ln">3349 </span></a>                <span class="s1">ret[k] = v</span>
3370 <a name="l3350"><span class="ln">3350 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">ret</span>
3371 <a name="l3351"><span class="ln">3351 </span></a>
3372 <a name="l3352"><span class="ln">3352 </span></a>    <span class="s3">def </span><span class="s1">parseImplAsGroupList(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3373 <a name="l3353"><span class="ln">3353 </span></a>        <span class="s1">result = self.re_match(instring</span><span class="s3">, </span><span class="s1">loc)</span>
3374 <a name="l3354"><span class="ln">3354 </span></a>        <span class="s3">if not </span><span class="s1">result:</span>
3375 <a name="l3355"><span class="ln">3355 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3376 <a name="l3356"><span class="ln">3356 </span></a>
3377 <a name="l3357"><span class="ln">3357 </span></a>        <span class="s1">loc = result.end()</span>
3378 <a name="l3358"><span class="ln">3358 </span></a>        <span class="s1">ret = result.groups()</span>
3379 <a name="l3359"><span class="ln">3359 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">ret</span>
3380 <a name="l3360"><span class="ln">3360 </span></a>
3381 <a name="l3361"><span class="ln">3361 </span></a>    <span class="s3">def </span><span class="s1">parseImplAsMatch(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3382 <a name="l3362"><span class="ln">3362 </span></a>        <span class="s1">result = self.re_match(instring</span><span class="s3">, </span><span class="s1">loc)</span>
3383 <a name="l3363"><span class="ln">3363 </span></a>        <span class="s3">if not </span><span class="s1">result:</span>
3384 <a name="l3364"><span class="ln">3364 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3385 <a name="l3365"><span class="ln">3365 </span></a>
3386 <a name="l3366"><span class="ln">3366 </span></a>        <span class="s1">loc = result.end()</span>
3387 <a name="l3367"><span class="ln">3367 </span></a>        <span class="s1">ret = result</span>
3388 <a name="l3368"><span class="ln">3368 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">ret</span>
3389 <a name="l3369"><span class="ln">3369 </span></a>
3390 <a name="l3370"><span class="ln">3370 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
3391 <a name="l3371"><span class="ln">3371 </span></a>        <span class="s3">try</span><span class="s1">:</span>
3392 <a name="l3372"><span class="ln">3372 </span></a>            <span class="s3">return </span><span class="s1">super(Regex</span><span class="s3">, </span><span class="s1">self).__str__()</span>
3393 <a name="l3373"><span class="ln">3373 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
3394 <a name="l3374"><span class="ln">3374 </span></a>            <span class="s3">pass</span>
3395 <a name="l3375"><span class="ln">3375 </span></a>
3396 <a name="l3376"><span class="ln">3376 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
3397 <a name="l3377"><span class="ln">3377 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;Re:(%s)&quot; </span><span class="s1">% repr(self.pattern)</span>
3398 <a name="l3378"><span class="ln">3378 </span></a>
3399 <a name="l3379"><span class="ln">3379 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
3400 <a name="l3380"><span class="ln">3380 </span></a>
3401 <a name="l3381"><span class="ln">3381 </span></a>    <span class="s3">def </span><span class="s1">sub(self</span><span class="s3">, </span><span class="s1">repl):</span>
3402 <a name="l3382"><span class="ln">3382 </span></a>        <span class="s5">r&quot;&quot;&quot; 
3403 <a name="l3383"><span class="ln">3383 </span></a>        Return Regex with an attached parse action to transform the parsed 
3404 <a name="l3384"><span class="ln">3384 </span></a>        result as if called using `re.sub(expr, repl, string) &lt;https://docs.python.org/3/library/re.html#re.sub&gt;`_. 
3405 <a name="l3385"><span class="ln">3385 </span></a> 
3406 <a name="l3386"><span class="ln">3386 </span></a>        Example:: 
3407 <a name="l3387"><span class="ln">3387 </span></a> 
3408 <a name="l3388"><span class="ln">3388 </span></a>            make_html = Regex(r&quot;(\w+):(.*?):&quot;).sub(r&quot;&lt;\1&gt;\2&lt;/\1&gt;&quot;) 
3409 <a name="l3389"><span class="ln">3389 </span></a>            print(make_html.transformString(&quot;h1:main title:&quot;)) 
3410 <a name="l3390"><span class="ln">3390 </span></a>            # prints &quot;&lt;h1&gt;main title&lt;/h1&gt;&quot; 
3411 <a name="l3391"><span class="ln">3391 </span></a>        &quot;&quot;&quot;</span>
3412 <a name="l3392"><span class="ln">3392 </span></a>        <span class="s3">if </span><span class="s1">self.asGroupList:</span>
3413 <a name="l3393"><span class="ln">3393 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;cannot use sub() with Regex(asGroupList=True)&quot;</span><span class="s3">,</span>
3414 <a name="l3394"><span class="ln">3394 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3415 <a name="l3395"><span class="ln">3395 </span></a>            <span class="s3">raise </span><span class="s1">SyntaxError()</span>
3416 <a name="l3396"><span class="ln">3396 </span></a>
3417 <a name="l3397"><span class="ln">3397 </span></a>        <span class="s3">if </span><span class="s1">self.asMatch </span><span class="s3">and </span><span class="s1">callable(repl):</span>
3418 <a name="l3398"><span class="ln">3398 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;cannot use sub() with a callable with Regex(asMatch=True)&quot;</span><span class="s3">,</span>
3419 <a name="l3399"><span class="ln">3399 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3420 <a name="l3400"><span class="ln">3400 </span></a>            <span class="s3">raise </span><span class="s1">SyntaxError()</span>
3421 <a name="l3401"><span class="ln">3401 </span></a>
3422 <a name="l3402"><span class="ln">3402 </span></a>        <span class="s3">if </span><span class="s1">self.asMatch:</span>
3423 <a name="l3403"><span class="ln">3403 </span></a>            <span class="s3">def </span><span class="s1">pa(tokens):</span>
3424 <a name="l3404"><span class="ln">3404 </span></a>                <span class="s3">return </span><span class="s1">tokens[</span><span class="s4">0</span><span class="s1">].expand(repl)</span>
3425 <a name="l3405"><span class="ln">3405 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3426 <a name="l3406"><span class="ln">3406 </span></a>            <span class="s3">def </span><span class="s1">pa(tokens):</span>
3427 <a name="l3407"><span class="ln">3407 </span></a>                <span class="s3">return </span><span class="s1">self.re.sub(repl</span><span class="s3">, </span><span class="s1">tokens[</span><span class="s4">0</span><span class="s1">])</span>
3428 <a name="l3408"><span class="ln">3408 </span></a>        <span class="s3">return </span><span class="s1">self.addParseAction(pa)</span>
3429 <a name="l3409"><span class="ln">3409 </span></a>
3430 <a name="l3410"><span class="ln">3410 </span></a><span class="s3">class </span><span class="s1">QuotedString(Token):</span>
3431 <a name="l3411"><span class="ln">3411 </span></a>    <span class="s5">r&quot;&quot;&quot; 
3432 <a name="l3412"><span class="ln">3412 </span></a>    Token for matching strings that are delimited by quoting characters. 
3433 <a name="l3413"><span class="ln">3413 </span></a> 
3434 <a name="l3414"><span class="ln">3414 </span></a>    Defined with the following parameters: 
3435 <a name="l3415"><span class="ln">3415 </span></a> 
3436 <a name="l3416"><span class="ln">3416 </span></a>        - quoteChar - string of one or more characters defining the 
3437 <a name="l3417"><span class="ln">3417 </span></a>          quote delimiting string 
3438 <a name="l3418"><span class="ln">3418 </span></a>        - escChar - character to escape quotes, typically backslash 
3439 <a name="l3419"><span class="ln">3419 </span></a>          (default= ``None``) 
3440 <a name="l3420"><span class="ln">3420 </span></a>        - escQuote - special quote sequence to escape an embedded quote 
3441 <a name="l3421"><span class="ln">3421 </span></a>          string (such as SQL's ``&quot;&quot;`` to escape an embedded ``&quot;``) 
3442 <a name="l3422"><span class="ln">3422 </span></a>          (default= ``None``) 
3443 <a name="l3423"><span class="ln">3423 </span></a>        - multiline - boolean indicating whether quotes can span 
3444 <a name="l3424"><span class="ln">3424 </span></a>          multiple lines (default= ``False``) 
3445 <a name="l3425"><span class="ln">3425 </span></a>        - unquoteResults - boolean indicating whether the matched text 
3446 <a name="l3426"><span class="ln">3426 </span></a>          should be unquoted (default= ``True``) 
3447 <a name="l3427"><span class="ln">3427 </span></a>        - endQuoteChar - string of one or more characters defining the 
3448 <a name="l3428"><span class="ln">3428 </span></a>          end of the quote delimited string (default= ``None``  =&gt; same as 
3449 <a name="l3429"><span class="ln">3429 </span></a>          quoteChar) 
3450 <a name="l3430"><span class="ln">3430 </span></a>        - convertWhitespaceEscapes - convert escaped whitespace 
3451 <a name="l3431"><span class="ln">3431 </span></a>          (``'\t'``, ``'\n'``, etc.) to actual whitespace 
3452 <a name="l3432"><span class="ln">3432 </span></a>          (default= ``True``) 
3453 <a name="l3433"><span class="ln">3433 </span></a> 
3454 <a name="l3434"><span class="ln">3434 </span></a>    Example:: 
3455 <a name="l3435"><span class="ln">3435 </span></a> 
3456 <a name="l3436"><span class="ln">3436 </span></a>        qs = QuotedString('&quot;') 
3457 <a name="l3437"><span class="ln">3437 </span></a>        print(qs.searchString('lsjdf &quot;This is the quote&quot; sldjf')) 
3458 <a name="l3438"><span class="ln">3438 </span></a>        complex_qs = QuotedString('{{', endQuoteChar='}}') 
3459 <a name="l3439"><span class="ln">3439 </span></a>        print(complex_qs.searchString('lsjdf {{This is the &quot;quote&quot;}} sldjf')) 
3460 <a name="l3440"><span class="ln">3440 </span></a>        sql_qs = QuotedString('&quot;', escQuote='&quot;&quot;') 
3461 <a name="l3441"><span class="ln">3441 </span></a>        print(sql_qs.searchString('lsjdf &quot;This is the quote with &quot;&quot;embedded&quot;&quot; quotes&quot; sldjf')) 
3462 <a name="l3442"><span class="ln">3442 </span></a> 
3463 <a name="l3443"><span class="ln">3443 </span></a>    prints:: 
3464 <a name="l3444"><span class="ln">3444 </span></a> 
3465 <a name="l3445"><span class="ln">3445 </span></a>        [['This is the quote']] 
3466 <a name="l3446"><span class="ln">3446 </span></a>        [['This is the &quot;quote&quot;']] 
3467 <a name="l3447"><span class="ln">3447 </span></a>        [['This is the quote with &quot;embedded&quot; quotes']] 
3468 <a name="l3448"><span class="ln">3448 </span></a>    &quot;&quot;&quot;</span>
3469 <a name="l3449"><span class="ln">3449 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">quoteChar</span><span class="s3">, </span><span class="s1">escChar=</span><span class="s3">None, </span><span class="s1">escQuote=</span><span class="s3">None, </span><span class="s1">multiline=</span><span class="s3">False,</span>
3470 <a name="l3450"><span class="ln">3450 </span></a>                 <span class="s1">unquoteResults=</span><span class="s3">True, </span><span class="s1">endQuoteChar=</span><span class="s3">None, </span><span class="s1">convertWhitespaceEscapes=</span><span class="s3">True</span><span class="s1">):</span>
3471 <a name="l3451"><span class="ln">3451 </span></a>        <span class="s1">super(QuotedString</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3472 <a name="l3452"><span class="ln">3452 </span></a>
3473 <a name="l3453"><span class="ln">3453 </span></a>        <span class="s0"># remove white space from quote chars - wont work anyway</span>
3474 <a name="l3454"><span class="ln">3454 </span></a>        <span class="s1">quoteChar = quoteChar.strip()</span>
3475 <a name="l3455"><span class="ln">3455 </span></a>        <span class="s3">if not </span><span class="s1">quoteChar:</span>
3476 <a name="l3456"><span class="ln">3456 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;quoteChar cannot be the empty string&quot;</span><span class="s3">, </span><span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3477 <a name="l3457"><span class="ln">3457 </span></a>            <span class="s3">raise </span><span class="s1">SyntaxError()</span>
3478 <a name="l3458"><span class="ln">3458 </span></a>
3479 <a name="l3459"><span class="ln">3459 </span></a>        <span class="s3">if </span><span class="s1">endQuoteChar </span><span class="s3">is None</span><span class="s1">:</span>
3480 <a name="l3460"><span class="ln">3460 </span></a>            <span class="s1">endQuoteChar = quoteChar</span>
3481 <a name="l3461"><span class="ln">3461 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3482 <a name="l3462"><span class="ln">3462 </span></a>            <span class="s1">endQuoteChar = endQuoteChar.strip()</span>
3483 <a name="l3463"><span class="ln">3463 </span></a>            <span class="s3">if not </span><span class="s1">endQuoteChar:</span>
3484 <a name="l3464"><span class="ln">3464 </span></a>                <span class="s1">warnings.warn(</span><span class="s2">&quot;endQuoteChar cannot be the empty string&quot;</span><span class="s3">, </span><span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3485 <a name="l3465"><span class="ln">3465 </span></a>                <span class="s3">raise </span><span class="s1">SyntaxError()</span>
3486 <a name="l3466"><span class="ln">3466 </span></a>
3487 <a name="l3467"><span class="ln">3467 </span></a>        <span class="s1">self.quoteChar = quoteChar</span>
3488 <a name="l3468"><span class="ln">3468 </span></a>        <span class="s1">self.quoteCharLen = len(quoteChar)</span>
3489 <a name="l3469"><span class="ln">3469 </span></a>        <span class="s1">self.firstQuoteChar = quoteChar[</span><span class="s4">0</span><span class="s1">]</span>
3490 <a name="l3470"><span class="ln">3470 </span></a>        <span class="s1">self.endQuoteChar = endQuoteChar</span>
3491 <a name="l3471"><span class="ln">3471 </span></a>        <span class="s1">self.endQuoteCharLen = len(endQuoteChar)</span>
3492 <a name="l3472"><span class="ln">3472 </span></a>        <span class="s1">self.escChar = escChar</span>
3493 <a name="l3473"><span class="ln">3473 </span></a>        <span class="s1">self.escQuote = escQuote</span>
3494 <a name="l3474"><span class="ln">3474 </span></a>        <span class="s1">self.unquoteResults = unquoteResults</span>
3495 <a name="l3475"><span class="ln">3475 </span></a>        <span class="s1">self.convertWhitespaceEscapes = convertWhitespaceEscapes</span>
3496 <a name="l3476"><span class="ln">3476 </span></a>
3497 <a name="l3477"><span class="ln">3477 </span></a>        <span class="s3">if </span><span class="s1">multiline:</span>
3498 <a name="l3478"><span class="ln">3478 </span></a>            <span class="s1">self.flags = re.MULTILINE | re.DOTALL</span>
3499 <a name="l3479"><span class="ln">3479 </span></a>            <span class="s1">self.pattern = </span><span class="s2">r'%s(?:[^%s%s]' </span><span class="s1">% (re.escape(self.quoteChar)</span><span class="s3">,</span>
3500 <a name="l3480"><span class="ln">3480 </span></a>                                              <span class="s1">_escapeRegexRangeChars(self.endQuoteChar[</span><span class="s4">0</span><span class="s1">])</span><span class="s3">,</span>
3501 <a name="l3481"><span class="ln">3481 </span></a>                                              <span class="s1">(escChar </span><span class="s3">is not None and </span><span class="s1">_escapeRegexRangeChars(escChar) </span><span class="s3">or </span><span class="s2">''</span><span class="s1">))</span>
3502 <a name="l3482"><span class="ln">3482 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3503 <a name="l3483"><span class="ln">3483 </span></a>            <span class="s1">self.flags = </span><span class="s4">0</span>
3504 <a name="l3484"><span class="ln">3484 </span></a>            <span class="s1">self.pattern = </span><span class="s2">r'%s(?:[^%s\n\r%s]' </span><span class="s1">% (re.escape(self.quoteChar)</span><span class="s3">,</span>
3505 <a name="l3485"><span class="ln">3485 </span></a>                                                  <span class="s1">_escapeRegexRangeChars(self.endQuoteChar[</span><span class="s4">0</span><span class="s1">])</span><span class="s3">,</span>
3506 <a name="l3486"><span class="ln">3486 </span></a>                                                  <span class="s1">(escChar </span><span class="s3">is not None and </span><span class="s1">_escapeRegexRangeChars(escChar) </span><span class="s3">or </span><span class="s2">''</span><span class="s1">))</span>
3507 <a name="l3487"><span class="ln">3487 </span></a>        <span class="s3">if </span><span class="s1">len(self.endQuoteChar) &gt; </span><span class="s4">1</span><span class="s1">:</span>
3508 <a name="l3488"><span class="ln">3488 </span></a>            <span class="s1">self.pattern += (</span>
3509 <a name="l3489"><span class="ln">3489 </span></a>                <span class="s2">'|(?:' </span><span class="s1">+ </span><span class="s2">')|(?:'</span><span class="s1">.join(</span><span class="s2">&quot;%s[^%s]&quot; </span><span class="s1">% (re.escape(self.endQuoteChar[:i])</span><span class="s3">,</span>
3510 <a name="l3490"><span class="ln">3490 </span></a>                                                   <span class="s1">_escapeRegexRangeChars(self.endQuoteChar[i]))</span>
3511 <a name="l3491"><span class="ln">3491 </span></a>                                      <span class="s3">for </span><span class="s1">i </span><span class="s3">in </span><span class="s1">range(len(self.endQuoteChar) - </span><span class="s4">1</span><span class="s3">, </span><span class="s4">0</span><span class="s3">, </span><span class="s1">-</span><span class="s4">1</span><span class="s1">)) + </span><span class="s2">')'</span><span class="s1">)</span>
3512 <a name="l3492"><span class="ln">3492 </span></a>
3513 <a name="l3493"><span class="ln">3493 </span></a>        <span class="s3">if </span><span class="s1">escQuote:</span>
3514 <a name="l3494"><span class="ln">3494 </span></a>            <span class="s1">self.pattern += (</span><span class="s2">r'|(?:%s)' </span><span class="s1">% re.escape(escQuote))</span>
3515 <a name="l3495"><span class="ln">3495 </span></a>        <span class="s3">if </span><span class="s1">escChar:</span>
3516 <a name="l3496"><span class="ln">3496 </span></a>            <span class="s1">self.pattern += (</span><span class="s2">r'|(?:%s.)' </span><span class="s1">% re.escape(escChar))</span>
3517 <a name="l3497"><span class="ln">3497 </span></a>            <span class="s1">self.escCharReplacePattern = re.escape(self.escChar) + </span><span class="s2">&quot;(.)&quot;</span>
3518 <a name="l3498"><span class="ln">3498 </span></a>        <span class="s1">self.pattern += (</span><span class="s2">r')*%s' </span><span class="s1">% re.escape(self.endQuoteChar))</span>
3519 <a name="l3499"><span class="ln">3499 </span></a>
3520 <a name="l3500"><span class="ln">3500 </span></a>        <span class="s3">try</span><span class="s1">:</span>
3521 <a name="l3501"><span class="ln">3501 </span></a>            <span class="s1">self.re = re.compile(self.pattern</span><span class="s3">, </span><span class="s1">self.flags)</span>
3522 <a name="l3502"><span class="ln">3502 </span></a>            <span class="s1">self.reString = self.pattern</span>
3523 <a name="l3503"><span class="ln">3503 </span></a>            <span class="s1">self.re_match = self.re.match</span>
3524 <a name="l3504"><span class="ln">3504 </span></a>        <span class="s3">except </span><span class="s1">sre_constants.error:</span>
3525 <a name="l3505"><span class="ln">3505 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;invalid pattern (%s) passed to Regex&quot; </span><span class="s1">% self.pattern</span><span class="s3">,</span>
3526 <a name="l3506"><span class="ln">3506 </span></a>                          <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
3527 <a name="l3507"><span class="ln">3507 </span></a>            <span class="s3">raise</span>
3528 <a name="l3508"><span class="ln">3508 </span></a>
3529 <a name="l3509"><span class="ln">3509 </span></a>        <span class="s1">self.name = _ustr(self)</span>
3530 <a name="l3510"><span class="ln">3510 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
3531 <a name="l3511"><span class="ln">3511 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
3532 <a name="l3512"><span class="ln">3512 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
3533 <a name="l3513"><span class="ln">3513 </span></a>
3534 <a name="l3514"><span class="ln">3514 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3535 <a name="l3515"><span class="ln">3515 </span></a>        <span class="s1">result = instring[loc] == self.firstQuoteChar </span><span class="s3">and </span><span class="s1">self.re_match(instring</span><span class="s3">, </span><span class="s1">loc) </span><span class="s3">or None</span>
3536 <a name="l3516"><span class="ln">3516 </span></a>        <span class="s3">if not </span><span class="s1">result:</span>
3537 <a name="l3517"><span class="ln">3517 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3538 <a name="l3518"><span class="ln">3518 </span></a>
3539 <a name="l3519"><span class="ln">3519 </span></a>        <span class="s1">loc = result.end()</span>
3540 <a name="l3520"><span class="ln">3520 </span></a>        <span class="s1">ret = result.group()</span>
3541 <a name="l3521"><span class="ln">3521 </span></a>
3542 <a name="l3522"><span class="ln">3522 </span></a>        <span class="s3">if </span><span class="s1">self.unquoteResults:</span>
3543 <a name="l3523"><span class="ln">3523 </span></a>
3544 <a name="l3524"><span class="ln">3524 </span></a>            <span class="s0"># strip off quotes</span>
3545 <a name="l3525"><span class="ln">3525 </span></a>            <span class="s1">ret = ret[self.quoteCharLen: -self.endQuoteCharLen]</span>
3546 <a name="l3526"><span class="ln">3526 </span></a>
3547 <a name="l3527"><span class="ln">3527 </span></a>            <span class="s3">if </span><span class="s1">isinstance(ret</span><span class="s3">, </span><span class="s1">basestring):</span>
3548 <a name="l3528"><span class="ln">3528 </span></a>                <span class="s0"># replace escaped whitespace</span>
3549 <a name="l3529"><span class="ln">3529 </span></a>                <span class="s3">if </span><span class="s2">'</span><span class="s3">\\</span><span class="s2">' </span><span class="s3">in </span><span class="s1">ret </span><span class="s3">and </span><span class="s1">self.convertWhitespaceEscapes:</span>
3550 <a name="l3530"><span class="ln">3530 </span></a>                    <span class="s1">ws_map = {</span>
3551 <a name="l3531"><span class="ln">3531 </span></a>                        <span class="s2">r'\t'</span><span class="s1">: </span><span class="s2">'</span><span class="s3">\t</span><span class="s2">'</span><span class="s3">,</span>
3552 <a name="l3532"><span class="ln">3532 </span></a>                        <span class="s2">r'\n'</span><span class="s1">: </span><span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span><span class="s3">,</span>
3553 <a name="l3533"><span class="ln">3533 </span></a>                        <span class="s2">r'\f'</span><span class="s1">: </span><span class="s2">'</span><span class="s3">\f</span><span class="s2">'</span><span class="s3">,</span>
3554 <a name="l3534"><span class="ln">3534 </span></a>                        <span class="s2">r'\r'</span><span class="s1">: </span><span class="s2">'</span><span class="s3">\r</span><span class="s2">'</span><span class="s3">,</span>
3555 <a name="l3535"><span class="ln">3535 </span></a>                    <span class="s1">}</span>
3556 <a name="l3536"><span class="ln">3536 </span></a>                    <span class="s3">for </span><span class="s1">wslit</span><span class="s3">, </span><span class="s1">wschar </span><span class="s3">in </span><span class="s1">ws_map.items():</span>
3557 <a name="l3537"><span class="ln">3537 </span></a>                        <span class="s1">ret = ret.replace(wslit</span><span class="s3">, </span><span class="s1">wschar)</span>
3558 <a name="l3538"><span class="ln">3538 </span></a>
3559 <a name="l3539"><span class="ln">3539 </span></a>                <span class="s0"># replace escaped characters</span>
3560 <a name="l3540"><span class="ln">3540 </span></a>                <span class="s3">if </span><span class="s1">self.escChar:</span>
3561 <a name="l3541"><span class="ln">3541 </span></a>                    <span class="s1">ret = re.sub(self.escCharReplacePattern</span><span class="s3">, </span><span class="s2">r&quot;\g&lt;1&gt;&quot;</span><span class="s3">, </span><span class="s1">ret)</span>
3562 <a name="l3542"><span class="ln">3542 </span></a>
3563 <a name="l3543"><span class="ln">3543 </span></a>                <span class="s0"># replace escaped quotes</span>
3564 <a name="l3544"><span class="ln">3544 </span></a>                <span class="s3">if </span><span class="s1">self.escQuote:</span>
3565 <a name="l3545"><span class="ln">3545 </span></a>                    <span class="s1">ret = ret.replace(self.escQuote</span><span class="s3">, </span><span class="s1">self.endQuoteChar)</span>
3566 <a name="l3546"><span class="ln">3546 </span></a>
3567 <a name="l3547"><span class="ln">3547 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">ret</span>
3568 <a name="l3548"><span class="ln">3548 </span></a>
3569 <a name="l3549"><span class="ln">3549 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
3570 <a name="l3550"><span class="ln">3550 </span></a>        <span class="s3">try</span><span class="s1">:</span>
3571 <a name="l3551"><span class="ln">3551 </span></a>            <span class="s3">return </span><span class="s1">super(QuotedString</span><span class="s3">, </span><span class="s1">self).__str__()</span>
3572 <a name="l3552"><span class="ln">3552 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
3573 <a name="l3553"><span class="ln">3553 </span></a>            <span class="s3">pass</span>
3574 <a name="l3554"><span class="ln">3554 </span></a>
3575 <a name="l3555"><span class="ln">3555 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
3576 <a name="l3556"><span class="ln">3556 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;quoted string, starting with %s ending with %s&quot; </span><span class="s1">% (self.quoteChar</span><span class="s3">, </span><span class="s1">self.endQuoteChar)</span>
3577 <a name="l3557"><span class="ln">3557 </span></a>
3578 <a name="l3558"><span class="ln">3558 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
3579 <a name="l3559"><span class="ln">3559 </span></a>
3580 <a name="l3560"><span class="ln">3560 </span></a>
3581 <a name="l3561"><span class="ln">3561 </span></a><span class="s3">class </span><span class="s1">CharsNotIn(Token):</span>
3582 <a name="l3562"><span class="ln">3562 </span></a>    <span class="s5">&quot;&quot;&quot;Token for matching words composed of characters *not* in a given 
3583 <a name="l3563"><span class="ln">3563 </span></a>    set (will include whitespace in matched characters if not listed in 
3584 <a name="l3564"><span class="ln">3564 </span></a>    the provided exclusion set - see example). Defined with string 
3585 <a name="l3565"><span class="ln">3565 </span></a>    containing all disallowed characters, and an optional minimum, 
3586 <a name="l3566"><span class="ln">3566 </span></a>    maximum, and/or exact length.  The default value for ``min`` is 
3587 <a name="l3567"><span class="ln">3567 </span></a>    1 (a minimum value &lt; 1 is not valid); the default values for 
3588 <a name="l3568"><span class="ln">3568 </span></a>    ``max`` and ``exact`` are 0, meaning no maximum or exact 
3589 <a name="l3569"><span class="ln">3569 </span></a>    length restriction. 
3590 <a name="l3570"><span class="ln">3570 </span></a> 
3591 <a name="l3571"><span class="ln">3571 </span></a>    Example:: 
3592 <a name="l3572"><span class="ln">3572 </span></a> 
3593 <a name="l3573"><span class="ln">3573 </span></a>        # define a comma-separated-value as anything that is not a ',' 
3594 <a name="l3574"><span class="ln">3574 </span></a>        csv_value = CharsNotIn(',') 
3595 <a name="l3575"><span class="ln">3575 </span></a>        print(delimitedList(csv_value).parseString(&quot;dkls,lsdkjf,s12 34,@!#,213&quot;)) 
3596 <a name="l3576"><span class="ln">3576 </span></a> 
3597 <a name="l3577"><span class="ln">3577 </span></a>    prints:: 
3598 <a name="l3578"><span class="ln">3578 </span></a> 
3599 <a name="l3579"><span class="ln">3579 </span></a>        ['dkls', 'lsdkjf', 's12 34', '@!#', '213'] 
3600 <a name="l3580"><span class="ln">3580 </span></a>    &quot;&quot;&quot;</span>
3601 <a name="l3581"><span class="ln">3581 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">notChars</span><span class="s3">, </span><span class="s1">min=</span><span class="s4">1</span><span class="s3">, </span><span class="s1">max=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">0</span><span class="s1">):</span>
3602 <a name="l3582"><span class="ln">3582 </span></a>        <span class="s1">super(CharsNotIn</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3603 <a name="l3583"><span class="ln">3583 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
3604 <a name="l3584"><span class="ln">3584 </span></a>        <span class="s1">self.notChars = notChars</span>
3605 <a name="l3585"><span class="ln">3585 </span></a>
3606 <a name="l3586"><span class="ln">3586 </span></a>        <span class="s3">if </span><span class="s1">min &lt; </span><span class="s4">1</span><span class="s1">:</span>
3607 <a name="l3587"><span class="ln">3587 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;cannot specify a minimum length &lt; 1; use &quot;</span>
3608 <a name="l3588"><span class="ln">3588 </span></a>                             <span class="s2">&quot;Optional(CharsNotIn()) if zero-length char group is permitted&quot;</span><span class="s1">)</span>
3609 <a name="l3589"><span class="ln">3589 </span></a>
3610 <a name="l3590"><span class="ln">3590 </span></a>        <span class="s1">self.minLen = min</span>
3611 <a name="l3591"><span class="ln">3591 </span></a>
3612 <a name="l3592"><span class="ln">3592 </span></a>        <span class="s3">if </span><span class="s1">max &gt; </span><span class="s4">0</span><span class="s1">:</span>
3613 <a name="l3593"><span class="ln">3593 </span></a>            <span class="s1">self.maxLen = max</span>
3614 <a name="l3594"><span class="ln">3594 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3615 <a name="l3595"><span class="ln">3595 </span></a>            <span class="s1">self.maxLen = _MAX_INT</span>
3616 <a name="l3596"><span class="ln">3596 </span></a>
3617 <a name="l3597"><span class="ln">3597 </span></a>        <span class="s3">if </span><span class="s1">exact &gt; </span><span class="s4">0</span><span class="s1">:</span>
3618 <a name="l3598"><span class="ln">3598 </span></a>            <span class="s1">self.maxLen = exact</span>
3619 <a name="l3599"><span class="ln">3599 </span></a>            <span class="s1">self.minLen = exact</span>
3620 <a name="l3600"><span class="ln">3600 </span></a>
3621 <a name="l3601"><span class="ln">3601 </span></a>        <span class="s1">self.name = _ustr(self)</span>
3622 <a name="l3602"><span class="ln">3602 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
3623 <a name="l3603"><span class="ln">3603 </span></a>        <span class="s1">self.mayReturnEmpty = (self.minLen == </span><span class="s4">0</span><span class="s1">)</span>
3624 <a name="l3604"><span class="ln">3604 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
3625 <a name="l3605"><span class="ln">3605 </span></a>
3626 <a name="l3606"><span class="ln">3606 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3627 <a name="l3607"><span class="ln">3607 </span></a>        <span class="s3">if </span><span class="s1">instring[loc] </span><span class="s3">in </span><span class="s1">self.notChars:</span>
3628 <a name="l3608"><span class="ln">3608 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3629 <a name="l3609"><span class="ln">3609 </span></a>
3630 <a name="l3610"><span class="ln">3610 </span></a>        <span class="s1">start = loc</span>
3631 <a name="l3611"><span class="ln">3611 </span></a>        <span class="s1">loc += </span><span class="s4">1</span>
3632 <a name="l3612"><span class="ln">3612 </span></a>        <span class="s1">notchars = self.notChars</span>
3633 <a name="l3613"><span class="ln">3613 </span></a>        <span class="s1">maxlen = min(start + self.maxLen</span><span class="s3">, </span><span class="s1">len(instring))</span>
3634 <a name="l3614"><span class="ln">3614 </span></a>        <span class="s3">while </span><span class="s1">loc &lt; maxlen </span><span class="s3">and </span><span class="s1">instring[loc] </span><span class="s3">not in </span><span class="s1">notchars:</span>
3635 <a name="l3615"><span class="ln">3615 </span></a>            <span class="s1">loc += </span><span class="s4">1</span>
3636 <a name="l3616"><span class="ln">3616 </span></a>
3637 <a name="l3617"><span class="ln">3617 </span></a>        <span class="s3">if </span><span class="s1">loc - start &lt; self.minLen:</span>
3638 <a name="l3618"><span class="ln">3618 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3639 <a name="l3619"><span class="ln">3619 </span></a>
3640 <a name="l3620"><span class="ln">3620 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">instring[start:loc]</span>
3641 <a name="l3621"><span class="ln">3621 </span></a>
3642 <a name="l3622"><span class="ln">3622 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
3643 <a name="l3623"><span class="ln">3623 </span></a>        <span class="s3">try</span><span class="s1">:</span>
3644 <a name="l3624"><span class="ln">3624 </span></a>            <span class="s3">return </span><span class="s1">super(CharsNotIn</span><span class="s3">, </span><span class="s1">self).__str__()</span>
3645 <a name="l3625"><span class="ln">3625 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
3646 <a name="l3626"><span class="ln">3626 </span></a>            <span class="s3">pass</span>
3647 <a name="l3627"><span class="ln">3627 </span></a>
3648 <a name="l3628"><span class="ln">3628 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
3649 <a name="l3629"><span class="ln">3629 </span></a>            <span class="s3">if </span><span class="s1">len(self.notChars) &gt; </span><span class="s4">4</span><span class="s1">:</span>
3650 <a name="l3630"><span class="ln">3630 </span></a>                <span class="s1">self.strRepr = </span><span class="s2">&quot;!W:(%s...)&quot; </span><span class="s1">% self.notChars[:</span><span class="s4">4</span><span class="s1">]</span>
3651 <a name="l3631"><span class="ln">3631 </span></a>            <span class="s3">else</span><span class="s1">:</span>
3652 <a name="l3632"><span class="ln">3632 </span></a>                <span class="s1">self.strRepr = </span><span class="s2">&quot;!W:(%s)&quot; </span><span class="s1">% self.notChars</span>
3653 <a name="l3633"><span class="ln">3633 </span></a>
3654 <a name="l3634"><span class="ln">3634 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
3655 <a name="l3635"><span class="ln">3635 </span></a>
3656 <a name="l3636"><span class="ln">3636 </span></a><span class="s3">class </span><span class="s1">White(Token):</span>
3657 <a name="l3637"><span class="ln">3637 </span></a>    <span class="s5">&quot;&quot;&quot;Special matching class for matching whitespace.  Normally, 
3658 <a name="l3638"><span class="ln">3638 </span></a>    whitespace is ignored by pyparsing grammars.  This class is included 
3659 <a name="l3639"><span class="ln">3639 </span></a>    when some whitespace structures are significant.  Define with 
3660 <a name="l3640"><span class="ln">3640 </span></a>    a string containing the whitespace characters to be matched; default 
3661 <a name="l3641"><span class="ln">3641 </span></a>    is ``&quot; \\t\\r\\n&quot;``.  Also takes optional ``min``, 
3662 <a name="l3642"><span class="ln">3642 </span></a>    ``max``, and ``exact`` arguments, as defined for the 
3663 <a name="l3643"><span class="ln">3643 </span></a>    :class:`Word` class. 
3664 <a name="l3644"><span class="ln">3644 </span></a>    &quot;&quot;&quot;</span>
3665 <a name="l3645"><span class="ln">3645 </span></a>    <span class="s1">whiteStrs = {</span>
3666 <a name="l3646"><span class="ln">3646 </span></a>        <span class="s2">' ' </span><span class="s1">: </span><span class="s2">'&lt;SP&gt;'</span><span class="s3">,</span>
3667 <a name="l3647"><span class="ln">3647 </span></a>        <span class="s2">'</span><span class="s3">\t</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;TAB&gt;'</span><span class="s3">,</span>
3668 <a name="l3648"><span class="ln">3648 </span></a>        <span class="s2">'</span><span class="s3">\n</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;LF&gt;'</span><span class="s3">,</span>
3669 <a name="l3649"><span class="ln">3649 </span></a>        <span class="s2">'</span><span class="s3">\r</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;CR&gt;'</span><span class="s3">,</span>
3670 <a name="l3650"><span class="ln">3650 </span></a>        <span class="s2">'</span><span class="s3">\f</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;FF&gt;'</span><span class="s3">,</span>
3671 <a name="l3651"><span class="ln">3651 </span></a>        <span class="s2">u'</span><span class="s3">\u00A0</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;NBSP&gt;'</span><span class="s3">,</span>
3672 <a name="l3652"><span class="ln">3652 </span></a>        <span class="s2">u'</span><span class="s3">\u1680</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;OGHAM_SPACE_MARK&gt;'</span><span class="s3">,</span>
3673 <a name="l3653"><span class="ln">3653 </span></a>        <span class="s2">u'</span><span class="s3">\u180E</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;MONGOLIAN_VOWEL_SEPARATOR&gt;'</span><span class="s3">,</span>
3674 <a name="l3654"><span class="ln">3654 </span></a>        <span class="s2">u'</span><span class="s3">\u2000</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;EN_QUAD&gt;'</span><span class="s3">,</span>
3675 <a name="l3655"><span class="ln">3655 </span></a>        <span class="s2">u'</span><span class="s3">\u2001</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;EM_QUAD&gt;'</span><span class="s3">,</span>
3676 <a name="l3656"><span class="ln">3656 </span></a>        <span class="s2">u'</span><span class="s3">\u2002</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;EN_SPACE&gt;'</span><span class="s3">,</span>
3677 <a name="l3657"><span class="ln">3657 </span></a>        <span class="s2">u'</span><span class="s3">\u2003</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;EM_SPACE&gt;'</span><span class="s3">,</span>
3678 <a name="l3658"><span class="ln">3658 </span></a>        <span class="s2">u'</span><span class="s3">\u2004</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;THREE-PER-EM_SPACE&gt;'</span><span class="s3">,</span>
3679 <a name="l3659"><span class="ln">3659 </span></a>        <span class="s2">u'</span><span class="s3">\u2005</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;FOUR-PER-EM_SPACE&gt;'</span><span class="s3">,</span>
3680 <a name="l3660"><span class="ln">3660 </span></a>        <span class="s2">u'</span><span class="s3">\u2006</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;SIX-PER-EM_SPACE&gt;'</span><span class="s3">,</span>
3681 <a name="l3661"><span class="ln">3661 </span></a>        <span class="s2">u'</span><span class="s3">\u2007</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;FIGURE_SPACE&gt;'</span><span class="s3">,</span>
3682 <a name="l3662"><span class="ln">3662 </span></a>        <span class="s2">u'</span><span class="s3">\u2008</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;PUNCTUATION_SPACE&gt;'</span><span class="s3">,</span>
3683 <a name="l3663"><span class="ln">3663 </span></a>        <span class="s2">u'</span><span class="s3">\u2009</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;THIN_SPACE&gt;'</span><span class="s3">,</span>
3684 <a name="l3664"><span class="ln">3664 </span></a>        <span class="s2">u'</span><span class="s3">\u200A</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;HAIR_SPACE&gt;'</span><span class="s3">,</span>
3685 <a name="l3665"><span class="ln">3665 </span></a>        <span class="s2">u'</span><span class="s3">\u200B</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;ZERO_WIDTH_SPACE&gt;'</span><span class="s3">,</span>
3686 <a name="l3666"><span class="ln">3666 </span></a>        <span class="s2">u'</span><span class="s3">\u202F</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;NNBSP&gt;'</span><span class="s3">,</span>
3687 <a name="l3667"><span class="ln">3667 </span></a>        <span class="s2">u'</span><span class="s3">\u205F</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;MMSP&gt;'</span><span class="s3">,</span>
3688 <a name="l3668"><span class="ln">3668 </span></a>        <span class="s2">u'</span><span class="s3">\u3000</span><span class="s2">'</span><span class="s1">: </span><span class="s2">'&lt;IDEOGRAPHIC_SPACE&gt;'</span><span class="s3">,</span>
3689 <a name="l3669"><span class="ln">3669 </span></a>        <span class="s1">}</span>
3690 <a name="l3670"><span class="ln">3670 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">ws=</span><span class="s2">&quot; </span><span class="s3">\t\r\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s1">min=</span><span class="s4">1</span><span class="s3">, </span><span class="s1">max=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">0</span><span class="s1">):</span>
3691 <a name="l3671"><span class="ln">3671 </span></a>        <span class="s1">super(White</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3692 <a name="l3672"><span class="ln">3672 </span></a>        <span class="s1">self.matchWhite = ws</span>
3693 <a name="l3673"><span class="ln">3673 </span></a>        <span class="s1">self.setWhitespaceChars(</span><span class="s2">&quot;&quot;</span><span class="s1">.join(c </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">self.whiteChars </span><span class="s3">if </span><span class="s1">c </span><span class="s3">not in </span><span class="s1">self.matchWhite))</span>
3694 <a name="l3674"><span class="ln">3674 </span></a>        <span class="s0"># ~ self.leaveWhitespace()</span>
3695 <a name="l3675"><span class="ln">3675 </span></a>        <span class="s1">self.name = (</span><span class="s2">&quot;&quot;</span><span class="s1">.join(White.whiteStrs[c] </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">self.matchWhite))</span>
3696 <a name="l3676"><span class="ln">3676 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
3697 <a name="l3677"><span class="ln">3677 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ self.name</span>
3698 <a name="l3678"><span class="ln">3678 </span></a>
3699 <a name="l3679"><span class="ln">3679 </span></a>        <span class="s1">self.minLen = min</span>
3700 <a name="l3680"><span class="ln">3680 </span></a>
3701 <a name="l3681"><span class="ln">3681 </span></a>        <span class="s3">if </span><span class="s1">max &gt; </span><span class="s4">0</span><span class="s1">:</span>
3702 <a name="l3682"><span class="ln">3682 </span></a>            <span class="s1">self.maxLen = max</span>
3703 <a name="l3683"><span class="ln">3683 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3704 <a name="l3684"><span class="ln">3684 </span></a>            <span class="s1">self.maxLen = _MAX_INT</span>
3705 <a name="l3685"><span class="ln">3685 </span></a>
3706 <a name="l3686"><span class="ln">3686 </span></a>        <span class="s3">if </span><span class="s1">exact &gt; </span><span class="s4">0</span><span class="s1">:</span>
3707 <a name="l3687"><span class="ln">3687 </span></a>            <span class="s1">self.maxLen = exact</span>
3708 <a name="l3688"><span class="ln">3688 </span></a>            <span class="s1">self.minLen = exact</span>
3709 <a name="l3689"><span class="ln">3689 </span></a>
3710 <a name="l3690"><span class="ln">3690 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3711 <a name="l3691"><span class="ln">3691 </span></a>        <span class="s3">if </span><span class="s1">instring[loc] </span><span class="s3">not in </span><span class="s1">self.matchWhite:</span>
3712 <a name="l3692"><span class="ln">3692 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3713 <a name="l3693"><span class="ln">3693 </span></a>        <span class="s1">start = loc</span>
3714 <a name="l3694"><span class="ln">3694 </span></a>        <span class="s1">loc += </span><span class="s4">1</span>
3715 <a name="l3695"><span class="ln">3695 </span></a>        <span class="s1">maxloc = start + self.maxLen</span>
3716 <a name="l3696"><span class="ln">3696 </span></a>        <span class="s1">maxloc = min(maxloc</span><span class="s3">, </span><span class="s1">len(instring))</span>
3717 <a name="l3697"><span class="ln">3697 </span></a>        <span class="s3">while </span><span class="s1">loc &lt; maxloc </span><span class="s3">and </span><span class="s1">instring[loc] </span><span class="s3">in </span><span class="s1">self.matchWhite:</span>
3718 <a name="l3698"><span class="ln">3698 </span></a>            <span class="s1">loc += </span><span class="s4">1</span>
3719 <a name="l3699"><span class="ln">3699 </span></a>
3720 <a name="l3700"><span class="ln">3700 </span></a>        <span class="s3">if </span><span class="s1">loc - start &lt; self.minLen:</span>
3721 <a name="l3701"><span class="ln">3701 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3722 <a name="l3702"><span class="ln">3702 </span></a>
3723 <a name="l3703"><span class="ln">3703 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">instring[start:loc]</span>
3724 <a name="l3704"><span class="ln">3704 </span></a>
3725 <a name="l3705"><span class="ln">3705 </span></a>
3726 <a name="l3706"><span class="ln">3706 </span></a><span class="s3">class </span><span class="s1">_PositionToken(Token):</span>
3727 <a name="l3707"><span class="ln">3707 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
3728 <a name="l3708"><span class="ln">3708 </span></a>        <span class="s1">super(_PositionToken</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3729 <a name="l3709"><span class="ln">3709 </span></a>        <span class="s1">self.name = self.__class__.__name__</span>
3730 <a name="l3710"><span class="ln">3710 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
3731 <a name="l3711"><span class="ln">3711 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
3732 <a name="l3712"><span class="ln">3712 </span></a>
3733 <a name="l3713"><span class="ln">3713 </span></a><span class="s3">class </span><span class="s1">GoToColumn(_PositionToken):</span>
3734 <a name="l3714"><span class="ln">3714 </span></a>    <span class="s5">&quot;&quot;&quot;Token to advance to a specific column of input text; useful for 
3735 <a name="l3715"><span class="ln">3715 </span></a>    tabular report scraping. 
3736 <a name="l3716"><span class="ln">3716 </span></a>    &quot;&quot;&quot;</span>
3737 <a name="l3717"><span class="ln">3717 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">colno):</span>
3738 <a name="l3718"><span class="ln">3718 </span></a>        <span class="s1">super(GoToColumn</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3739 <a name="l3719"><span class="ln">3719 </span></a>        <span class="s1">self.col = colno</span>
3740 <a name="l3720"><span class="ln">3720 </span></a>
3741 <a name="l3721"><span class="ln">3721 </span></a>    <span class="s3">def </span><span class="s1">preParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc):</span>
3742 <a name="l3722"><span class="ln">3722 </span></a>        <span class="s3">if </span><span class="s1">col(loc</span><span class="s3">, </span><span class="s1">instring) != self.col:</span>
3743 <a name="l3723"><span class="ln">3723 </span></a>            <span class="s1">instrlen = len(instring)</span>
3744 <a name="l3724"><span class="ln">3724 </span></a>            <span class="s3">if </span><span class="s1">self.ignoreExprs:</span>
3745 <a name="l3725"><span class="ln">3725 </span></a>                <span class="s1">loc = self._skipIgnorables(instring</span><span class="s3">, </span><span class="s1">loc)</span>
3746 <a name="l3726"><span class="ln">3726 </span></a>            <span class="s3">while </span><span class="s1">loc &lt; instrlen </span><span class="s3">and </span><span class="s1">instring[loc].isspace() </span><span class="s3">and </span><span class="s1">col(loc</span><span class="s3">, </span><span class="s1">instring) != self.col:</span>
3747 <a name="l3727"><span class="ln">3727 </span></a>                <span class="s1">loc += </span><span class="s4">1</span>
3748 <a name="l3728"><span class="ln">3728 </span></a>        <span class="s3">return </span><span class="s1">loc</span>
3749 <a name="l3729"><span class="ln">3729 </span></a>
3750 <a name="l3730"><span class="ln">3730 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3751 <a name="l3731"><span class="ln">3731 </span></a>        <span class="s1">thiscol = col(loc</span><span class="s3">, </span><span class="s1">instring)</span>
3752 <a name="l3732"><span class="ln">3732 </span></a>        <span class="s3">if </span><span class="s1">thiscol &gt; self.col:</span>
3753 <a name="l3733"><span class="ln">3733 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s2">&quot;Text not in expected column&quot;</span><span class="s3">, </span><span class="s1">self)</span>
3754 <a name="l3734"><span class="ln">3734 </span></a>        <span class="s1">newloc = loc + self.col - thiscol</span>
3755 <a name="l3735"><span class="ln">3735 </span></a>        <span class="s1">ret = instring[loc: newloc]</span>
3756 <a name="l3736"><span class="ln">3736 </span></a>        <span class="s3">return </span><span class="s1">newloc</span><span class="s3">, </span><span class="s1">ret</span>
3757 <a name="l3737"><span class="ln">3737 </span></a>
3758 <a name="l3738"><span class="ln">3738 </span></a>
3759 <a name="l3739"><span class="ln">3739 </span></a><span class="s3">class </span><span class="s1">LineStart(_PositionToken):</span>
3760 <a name="l3740"><span class="ln">3740 </span></a>    <span class="s5">r&quot;&quot;&quot;Matches if current position is at the beginning of a line within 
3761 <a name="l3741"><span class="ln">3741 </span></a>    the parse string 
3762 <a name="l3742"><span class="ln">3742 </span></a> 
3763 <a name="l3743"><span class="ln">3743 </span></a>    Example:: 
3764 <a name="l3744"><span class="ln">3744 </span></a> 
3765 <a name="l3745"><span class="ln">3745 </span></a>        test = '''\ 
3766 <a name="l3746"><span class="ln">3746 </span></a>        AAA this line 
3767 <a name="l3747"><span class="ln">3747 </span></a>        AAA and this line 
3768 <a name="l3748"><span class="ln">3748 </span></a>          AAA but not this one 
3769 <a name="l3749"><span class="ln">3749 </span></a>        B AAA and definitely not this one 
3770 <a name="l3750"><span class="ln">3750 </span></a>        ''' 
3771 <a name="l3751"><span class="ln">3751 </span></a> 
3772 <a name="l3752"><span class="ln">3752 </span></a>        for t in (LineStart() + 'AAA' + restOfLine).searchString(test): 
3773 <a name="l3753"><span class="ln">3753 </span></a>            print(t) 
3774 <a name="l3754"><span class="ln">3754 </span></a> 
3775 <a name="l3755"><span class="ln">3755 </span></a>    prints:: 
3776 <a name="l3756"><span class="ln">3756 </span></a> 
3777 <a name="l3757"><span class="ln">3757 </span></a>        ['AAA', ' this line'] 
3778 <a name="l3758"><span class="ln">3758 </span></a>        ['AAA', ' and this line'] 
3779 <a name="l3759"><span class="ln">3759 </span></a> 
3780 <a name="l3760"><span class="ln">3760 </span></a>    &quot;&quot;&quot;</span>
3781 <a name="l3761"><span class="ln">3761 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
3782 <a name="l3762"><span class="ln">3762 </span></a>        <span class="s1">super(LineStart</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3783 <a name="l3763"><span class="ln">3763 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected start of line&quot;</span>
3784 <a name="l3764"><span class="ln">3764 </span></a>
3785 <a name="l3765"><span class="ln">3765 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3786 <a name="l3766"><span class="ln">3766 </span></a>        <span class="s3">if </span><span class="s1">col(loc</span><span class="s3">, </span><span class="s1">instring) == </span><span class="s4">1</span><span class="s1">:</span>
3787 <a name="l3767"><span class="ln">3767 </span></a>            <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
3788 <a name="l3768"><span class="ln">3768 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3789 <a name="l3769"><span class="ln">3769 </span></a>
3790 <a name="l3770"><span class="ln">3770 </span></a><span class="s3">class </span><span class="s1">LineEnd(_PositionToken):</span>
3791 <a name="l3771"><span class="ln">3771 </span></a>    <span class="s5">&quot;&quot;&quot;Matches if current position is at the end of a line within the 
3792 <a name="l3772"><span class="ln">3772 </span></a>    parse string 
3793 <a name="l3773"><span class="ln">3773 </span></a>    &quot;&quot;&quot;</span>
3794 <a name="l3774"><span class="ln">3774 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
3795 <a name="l3775"><span class="ln">3775 </span></a>        <span class="s1">super(LineEnd</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3796 <a name="l3776"><span class="ln">3776 </span></a>        <span class="s1">self.setWhitespaceChars(ParserElement.DEFAULT_WHITE_CHARS.replace(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s2">&quot;&quot;</span><span class="s1">))</span>
3797 <a name="l3777"><span class="ln">3777 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected end of line&quot;</span>
3798 <a name="l3778"><span class="ln">3778 </span></a>
3799 <a name="l3779"><span class="ln">3779 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3800 <a name="l3780"><span class="ln">3780 </span></a>        <span class="s3">if </span><span class="s1">loc &lt; len(instring):</span>
3801 <a name="l3781"><span class="ln">3781 </span></a>            <span class="s3">if </span><span class="s1">instring[loc] == </span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s1">:</span>
3802 <a name="l3782"><span class="ln">3782 </span></a>                <span class="s3">return </span><span class="s1">loc + </span><span class="s4">1</span><span class="s3">, </span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span>
3803 <a name="l3783"><span class="ln">3783 </span></a>            <span class="s3">else</span><span class="s1">:</span>
3804 <a name="l3784"><span class="ln">3784 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3805 <a name="l3785"><span class="ln">3785 </span></a>        <span class="s3">elif </span><span class="s1">loc == len(instring):</span>
3806 <a name="l3786"><span class="ln">3786 </span></a>            <span class="s3">return </span><span class="s1">loc + </span><span class="s4">1</span><span class="s3">, </span><span class="s1">[]</span>
3807 <a name="l3787"><span class="ln">3787 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3808 <a name="l3788"><span class="ln">3788 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3809 <a name="l3789"><span class="ln">3789 </span></a>
3810 <a name="l3790"><span class="ln">3790 </span></a><span class="s3">class </span><span class="s1">StringStart(_PositionToken):</span>
3811 <a name="l3791"><span class="ln">3791 </span></a>    <span class="s5">&quot;&quot;&quot;Matches if current position is at the beginning of the parse 
3812 <a name="l3792"><span class="ln">3792 </span></a>    string 
3813 <a name="l3793"><span class="ln">3793 </span></a>    &quot;&quot;&quot;</span>
3814 <a name="l3794"><span class="ln">3794 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
3815 <a name="l3795"><span class="ln">3795 </span></a>        <span class="s1">super(StringStart</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3816 <a name="l3796"><span class="ln">3796 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected start of text&quot;</span>
3817 <a name="l3797"><span class="ln">3797 </span></a>
3818 <a name="l3798"><span class="ln">3798 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3819 <a name="l3799"><span class="ln">3799 </span></a>        <span class="s3">if </span><span class="s1">loc != </span><span class="s4">0</span><span class="s1">:</span>
3820 <a name="l3800"><span class="ln">3800 </span></a>            <span class="s0"># see if entire string up to here is just whitespace and ignoreables</span>
3821 <a name="l3801"><span class="ln">3801 </span></a>            <span class="s3">if </span><span class="s1">loc != self.preParse(instring</span><span class="s3">, </span><span class="s4">0</span><span class="s1">):</span>
3822 <a name="l3802"><span class="ln">3802 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3823 <a name="l3803"><span class="ln">3803 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
3824 <a name="l3804"><span class="ln">3804 </span></a>
3825 <a name="l3805"><span class="ln">3805 </span></a><span class="s3">class </span><span class="s1">StringEnd(_PositionToken):</span>
3826 <a name="l3806"><span class="ln">3806 </span></a>    <span class="s5">&quot;&quot;&quot;Matches if current position is at the end of the parse string 
3827 <a name="l3807"><span class="ln">3807 </span></a>    &quot;&quot;&quot;</span>
3828 <a name="l3808"><span class="ln">3808 </span></a>    <span class="s3">def </span><span class="s1">__init__(self):</span>
3829 <a name="l3809"><span class="ln">3809 </span></a>        <span class="s1">super(StringEnd</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3830 <a name="l3810"><span class="ln">3810 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected end of text&quot;</span>
3831 <a name="l3811"><span class="ln">3811 </span></a>
3832 <a name="l3812"><span class="ln">3812 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3833 <a name="l3813"><span class="ln">3813 </span></a>        <span class="s3">if </span><span class="s1">loc &lt; len(instring):</span>
3834 <a name="l3814"><span class="ln">3814 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3835 <a name="l3815"><span class="ln">3815 </span></a>        <span class="s3">elif </span><span class="s1">loc == len(instring):</span>
3836 <a name="l3816"><span class="ln">3816 </span></a>            <span class="s3">return </span><span class="s1">loc + </span><span class="s4">1</span><span class="s3">, </span><span class="s1">[]</span>
3837 <a name="l3817"><span class="ln">3817 </span></a>        <span class="s3">elif </span><span class="s1">loc &gt; len(instring):</span>
3838 <a name="l3818"><span class="ln">3818 </span></a>            <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
3839 <a name="l3819"><span class="ln">3819 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3840 <a name="l3820"><span class="ln">3820 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3841 <a name="l3821"><span class="ln">3821 </span></a>
3842 <a name="l3822"><span class="ln">3822 </span></a><span class="s3">class </span><span class="s1">WordStart(_PositionToken):</span>
3843 <a name="l3823"><span class="ln">3823 </span></a>    <span class="s5">&quot;&quot;&quot;Matches if the current position is at the beginning of a Word, 
3844 <a name="l3824"><span class="ln">3824 </span></a>    and is not preceded by any character in a given set of 
3845 <a name="l3825"><span class="ln">3825 </span></a>    ``wordChars`` (default= ``printables``). To emulate the 
3846 <a name="l3826"><span class="ln">3826 </span></a>    ``\b`` behavior of regular expressions, use 
3847 <a name="l3827"><span class="ln">3827 </span></a>    ``WordStart(alphanums)``. ``WordStart`` will also match at 
3848 <a name="l3828"><span class="ln">3828 </span></a>    the beginning of the string being parsed, or at the beginning of 
3849 <a name="l3829"><span class="ln">3829 </span></a>    a line. 
3850 <a name="l3830"><span class="ln">3830 </span></a>    &quot;&quot;&quot;</span>
3851 <a name="l3831"><span class="ln">3831 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">wordChars=printables):</span>
3852 <a name="l3832"><span class="ln">3832 </span></a>        <span class="s1">super(WordStart</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3853 <a name="l3833"><span class="ln">3833 </span></a>        <span class="s1">self.wordChars = set(wordChars)</span>
3854 <a name="l3834"><span class="ln">3834 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Not at the start of a word&quot;</span>
3855 <a name="l3835"><span class="ln">3835 </span></a>
3856 <a name="l3836"><span class="ln">3836 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3857 <a name="l3837"><span class="ln">3837 </span></a>        <span class="s3">if </span><span class="s1">loc != </span><span class="s4">0</span><span class="s1">:</span>
3858 <a name="l3838"><span class="ln">3838 </span></a>            <span class="s3">if </span><span class="s1">(instring[loc - </span><span class="s4">1</span><span class="s1">] </span><span class="s3">in </span><span class="s1">self.wordChars</span>
3859 <a name="l3839"><span class="ln">3839 </span></a>                    <span class="s3">or </span><span class="s1">instring[loc] </span><span class="s3">not in </span><span class="s1">self.wordChars):</span>
3860 <a name="l3840"><span class="ln">3840 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3861 <a name="l3841"><span class="ln">3841 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
3862 <a name="l3842"><span class="ln">3842 </span></a>
3863 <a name="l3843"><span class="ln">3843 </span></a><span class="s3">class </span><span class="s1">WordEnd(_PositionToken):</span>
3864 <a name="l3844"><span class="ln">3844 </span></a>    <span class="s5">&quot;&quot;&quot;Matches if the current position is at the end of a Word, and is 
3865 <a name="l3845"><span class="ln">3845 </span></a>    not followed by any character in a given set of ``wordChars`` 
3866 <a name="l3846"><span class="ln">3846 </span></a>    (default= ``printables``). To emulate the ``\b`` behavior of 
3867 <a name="l3847"><span class="ln">3847 </span></a>    regular expressions, use ``WordEnd(alphanums)``. ``WordEnd`` 
3868 <a name="l3848"><span class="ln">3848 </span></a>    will also match at the end of the string being parsed, or at the end 
3869 <a name="l3849"><span class="ln">3849 </span></a>    of a line. 
3870 <a name="l3850"><span class="ln">3850 </span></a>    &quot;&quot;&quot;</span>
3871 <a name="l3851"><span class="ln">3851 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">wordChars=printables):</span>
3872 <a name="l3852"><span class="ln">3852 </span></a>        <span class="s1">super(WordEnd</span><span class="s3">, </span><span class="s1">self).__init__()</span>
3873 <a name="l3853"><span class="ln">3853 </span></a>        <span class="s1">self.wordChars = set(wordChars)</span>
3874 <a name="l3854"><span class="ln">3854 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
3875 <a name="l3855"><span class="ln">3855 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Not at the end of a word&quot;</span>
3876 <a name="l3856"><span class="ln">3856 </span></a>
3877 <a name="l3857"><span class="ln">3857 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
3878 <a name="l3858"><span class="ln">3858 </span></a>        <span class="s1">instrlen = len(instring)</span>
3879 <a name="l3859"><span class="ln">3859 </span></a>        <span class="s3">if </span><span class="s1">instrlen &gt; </span><span class="s4">0 </span><span class="s3">and </span><span class="s1">loc &lt; instrlen:</span>
3880 <a name="l3860"><span class="ln">3860 </span></a>            <span class="s3">if </span><span class="s1">(instring[loc] </span><span class="s3">in </span><span class="s1">self.wordChars </span><span class="s3">or</span>
3881 <a name="l3861"><span class="ln">3861 </span></a>                    <span class="s1">instring[loc - </span><span class="s4">1</span><span class="s1">] </span><span class="s3">not in </span><span class="s1">self.wordChars):</span>
3882 <a name="l3862"><span class="ln">3862 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
3883 <a name="l3863"><span class="ln">3863 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
3884 <a name="l3864"><span class="ln">3864 </span></a>
3885 <a name="l3865"><span class="ln">3865 </span></a>
3886 <a name="l3866"><span class="ln">3866 </span></a><span class="s3">class </span><span class="s1">ParseExpression(ParserElement):</span>
3887 <a name="l3867"><span class="ln">3867 </span></a>    <span class="s5">&quot;&quot;&quot;Abstract subclass of ParserElement, for combining and 
3888 <a name="l3868"><span class="ln">3868 </span></a>    post-processing parsed tokens. 
3889 <a name="l3869"><span class="ln">3869 </span></a>    &quot;&quot;&quot;</span>
3890 <a name="l3870"><span class="ln">3870 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">exprs</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">):</span>
3891 <a name="l3871"><span class="ln">3871 </span></a>        <span class="s1">super(ParseExpression</span><span class="s3">, </span><span class="s1">self).__init__(savelist)</span>
3892 <a name="l3872"><span class="ln">3872 </span></a>        <span class="s3">if </span><span class="s1">isinstance(exprs</span><span class="s3">, </span><span class="s1">_generatorType):</span>
3893 <a name="l3873"><span class="ln">3873 </span></a>            <span class="s1">exprs = list(exprs)</span>
3894 <a name="l3874"><span class="ln">3874 </span></a>
3895 <a name="l3875"><span class="ln">3875 </span></a>        <span class="s3">if </span><span class="s1">isinstance(exprs</span><span class="s3">, </span><span class="s1">basestring):</span>
3896 <a name="l3876"><span class="ln">3876 </span></a>            <span class="s1">self.exprs = [self._literalStringClass(exprs)]</span>
3897 <a name="l3877"><span class="ln">3877 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(exprs</span><span class="s3">, </span><span class="s1">ParserElement):</span>
3898 <a name="l3878"><span class="ln">3878 </span></a>            <span class="s1">self.exprs = [exprs]</span>
3899 <a name="l3879"><span class="ln">3879 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(exprs</span><span class="s3">, </span><span class="s1">Iterable):</span>
3900 <a name="l3880"><span class="ln">3880 </span></a>            <span class="s1">exprs = list(exprs)</span>
3901 <a name="l3881"><span class="ln">3881 </span></a>            <span class="s0"># if sequence of strings provided, wrap with Literal</span>
3902 <a name="l3882"><span class="ln">3882 </span></a>            <span class="s3">if </span><span class="s1">any(isinstance(expr</span><span class="s3">, </span><span class="s1">basestring) </span><span class="s3">for </span><span class="s1">expr </span><span class="s3">in </span><span class="s1">exprs):</span>
3903 <a name="l3883"><span class="ln">3883 </span></a>                <span class="s1">exprs = (self._literalStringClass(e) </span><span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">basestring) </span><span class="s3">else </span><span class="s1">e </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">exprs)</span>
3904 <a name="l3884"><span class="ln">3884 </span></a>            <span class="s1">self.exprs = list(exprs)</span>
3905 <a name="l3885"><span class="ln">3885 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3906 <a name="l3886"><span class="ln">3886 </span></a>            <span class="s3">try</span><span class="s1">:</span>
3907 <a name="l3887"><span class="ln">3887 </span></a>                <span class="s1">self.exprs = list(exprs)</span>
3908 <a name="l3888"><span class="ln">3888 </span></a>            <span class="s3">except </span><span class="s1">TypeError:</span>
3909 <a name="l3889"><span class="ln">3889 </span></a>                <span class="s1">self.exprs = [exprs]</span>
3910 <a name="l3890"><span class="ln">3890 </span></a>        <span class="s1">self.callPreparse = </span><span class="s3">False</span>
3911 <a name="l3891"><span class="ln">3891 </span></a>
3912 <a name="l3892"><span class="ln">3892 </span></a>    <span class="s3">def </span><span class="s1">append(self</span><span class="s3">, </span><span class="s1">other):</span>
3913 <a name="l3893"><span class="ln">3893 </span></a>        <span class="s1">self.exprs.append(other)</span>
3914 <a name="l3894"><span class="ln">3894 </span></a>        <span class="s1">self.strRepr = </span><span class="s3">None</span>
3915 <a name="l3895"><span class="ln">3895 </span></a>        <span class="s3">return </span><span class="s1">self</span>
3916 <a name="l3896"><span class="ln">3896 </span></a>
3917 <a name="l3897"><span class="ln">3897 </span></a>    <span class="s3">def </span><span class="s1">leaveWhitespace(self):</span>
3918 <a name="l3898"><span class="ln">3898 </span></a>        <span class="s5">&quot;&quot;&quot;Extends ``leaveWhitespace`` defined in base class, and also invokes ``leaveWhitespace`` on 
3919 <a name="l3899"><span class="ln">3899 </span></a>           all contained expressions.&quot;&quot;&quot;</span>
3920 <a name="l3900"><span class="ln">3900 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
3921 <a name="l3901"><span class="ln">3901 </span></a>        <span class="s1">self.exprs = [e.copy() </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs]</span>
3922 <a name="l3902"><span class="ln">3902 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
3923 <a name="l3903"><span class="ln">3903 </span></a>            <span class="s1">e.leaveWhitespace()</span>
3924 <a name="l3904"><span class="ln">3904 </span></a>        <span class="s3">return </span><span class="s1">self</span>
3925 <a name="l3905"><span class="ln">3905 </span></a>
3926 <a name="l3906"><span class="ln">3906 </span></a>    <span class="s3">def </span><span class="s1">ignore(self</span><span class="s3">, </span><span class="s1">other):</span>
3927 <a name="l3907"><span class="ln">3907 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">Suppress):</span>
3928 <a name="l3908"><span class="ln">3908 </span></a>            <span class="s3">if </span><span class="s1">other </span><span class="s3">not in </span><span class="s1">self.ignoreExprs:</span>
3929 <a name="l3909"><span class="ln">3909 </span></a>                <span class="s1">super(ParseExpression</span><span class="s3">, </span><span class="s1">self).ignore(other)</span>
3930 <a name="l3910"><span class="ln">3910 </span></a>                <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
3931 <a name="l3911"><span class="ln">3911 </span></a>                    <span class="s1">e.ignore(self.ignoreExprs[-</span><span class="s4">1</span><span class="s1">])</span>
3932 <a name="l3912"><span class="ln">3912 </span></a>        <span class="s3">else</span><span class="s1">:</span>
3933 <a name="l3913"><span class="ln">3913 </span></a>            <span class="s1">super(ParseExpression</span><span class="s3">, </span><span class="s1">self).ignore(other)</span>
3934 <a name="l3914"><span class="ln">3914 </span></a>            <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
3935 <a name="l3915"><span class="ln">3915 </span></a>                <span class="s1">e.ignore(self.ignoreExprs[-</span><span class="s4">1</span><span class="s1">])</span>
3936 <a name="l3916"><span class="ln">3916 </span></a>        <span class="s3">return </span><span class="s1">self</span>
3937 <a name="l3917"><span class="ln">3917 </span></a>
3938 <a name="l3918"><span class="ln">3918 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
3939 <a name="l3919"><span class="ln">3919 </span></a>        <span class="s3">try</span><span class="s1">:</span>
3940 <a name="l3920"><span class="ln">3920 </span></a>            <span class="s3">return </span><span class="s1">super(ParseExpression</span><span class="s3">, </span><span class="s1">self).__str__()</span>
3941 <a name="l3921"><span class="ln">3921 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
3942 <a name="l3922"><span class="ln">3922 </span></a>            <span class="s3">pass</span>
3943 <a name="l3923"><span class="ln">3923 </span></a>
3944 <a name="l3924"><span class="ln">3924 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
3945 <a name="l3925"><span class="ln">3925 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;%s:(%s)&quot; </span><span class="s1">% (self.__class__.__name__</span><span class="s3">, </span><span class="s1">_ustr(self.exprs))</span>
3946 <a name="l3926"><span class="ln">3926 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
3947 <a name="l3927"><span class="ln">3927 </span></a>
3948 <a name="l3928"><span class="ln">3928 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
3949 <a name="l3929"><span class="ln">3929 </span></a>        <span class="s1">super(ParseExpression</span><span class="s3">, </span><span class="s1">self).streamline()</span>
3950 <a name="l3930"><span class="ln">3930 </span></a>
3951 <a name="l3931"><span class="ln">3931 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
3952 <a name="l3932"><span class="ln">3932 </span></a>            <span class="s1">e.streamline()</span>
3953 <a name="l3933"><span class="ln">3933 </span></a>
3954 <a name="l3934"><span class="ln">3934 </span></a>        <span class="s0"># collapse nested And's of the form And(And(And(a, b), c), d) to And(a, b, c, d)</span>
3955 <a name="l3935"><span class="ln">3935 </span></a>        <span class="s0"># but only if there are no parse actions or resultsNames on the nested And's</span>
3956 <a name="l3936"><span class="ln">3936 </span></a>        <span class="s0"># (likewise for Or's and MatchFirst's)</span>
3957 <a name="l3937"><span class="ln">3937 </span></a>        <span class="s3">if </span><span class="s1">len(self.exprs) == </span><span class="s4">2</span><span class="s1">:</span>
3958 <a name="l3938"><span class="ln">3938 </span></a>            <span class="s1">other = self.exprs[</span><span class="s4">0</span><span class="s1">]</span>
3959 <a name="l3939"><span class="ln">3939 </span></a>            <span class="s3">if </span><span class="s1">(isinstance(other</span><span class="s3">, </span><span class="s1">self.__class__)</span>
3960 <a name="l3940"><span class="ln">3940 </span></a>                    <span class="s3">and not </span><span class="s1">other.parseAction</span>
3961 <a name="l3941"><span class="ln">3941 </span></a>                    <span class="s3">and </span><span class="s1">other.resultsName </span><span class="s3">is None</span>
3962 <a name="l3942"><span class="ln">3942 </span></a>                    <span class="s3">and not </span><span class="s1">other.debug):</span>
3963 <a name="l3943"><span class="ln">3943 </span></a>                <span class="s1">self.exprs = other.exprs[:] + [self.exprs[</span><span class="s4">1</span><span class="s1">]]</span>
3964 <a name="l3944"><span class="ln">3944 </span></a>                <span class="s1">self.strRepr = </span><span class="s3">None</span>
3965 <a name="l3945"><span class="ln">3945 </span></a>                <span class="s1">self.mayReturnEmpty |= other.mayReturnEmpty</span>
3966 <a name="l3946"><span class="ln">3946 </span></a>                <span class="s1">self.mayIndexError  |= other.mayIndexError</span>
3967 <a name="l3947"><span class="ln">3947 </span></a>
3968 <a name="l3948"><span class="ln">3948 </span></a>            <span class="s1">other = self.exprs[-</span><span class="s4">1</span><span class="s1">]</span>
3969 <a name="l3949"><span class="ln">3949 </span></a>            <span class="s3">if </span><span class="s1">(isinstance(other</span><span class="s3">, </span><span class="s1">self.__class__)</span>
3970 <a name="l3950"><span class="ln">3950 </span></a>                    <span class="s3">and not </span><span class="s1">other.parseAction</span>
3971 <a name="l3951"><span class="ln">3951 </span></a>                    <span class="s3">and </span><span class="s1">other.resultsName </span><span class="s3">is None</span>
3972 <a name="l3952"><span class="ln">3952 </span></a>                    <span class="s3">and not </span><span class="s1">other.debug):</span>
3973 <a name="l3953"><span class="ln">3953 </span></a>                <span class="s1">self.exprs = self.exprs[:-</span><span class="s4">1</span><span class="s1">] + other.exprs[:]</span>
3974 <a name="l3954"><span class="ln">3954 </span></a>                <span class="s1">self.strRepr = </span><span class="s3">None</span>
3975 <a name="l3955"><span class="ln">3955 </span></a>                <span class="s1">self.mayReturnEmpty |= other.mayReturnEmpty</span>
3976 <a name="l3956"><span class="ln">3956 </span></a>                <span class="s1">self.mayIndexError  |= other.mayIndexError</span>
3977 <a name="l3957"><span class="ln">3957 </span></a>
3978 <a name="l3958"><span class="ln">3958 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Expected &quot; </span><span class="s1">+ _ustr(self)</span>
3979 <a name="l3959"><span class="ln">3959 </span></a>
3980 <a name="l3960"><span class="ln">3960 </span></a>        <span class="s3">return </span><span class="s1">self</span>
3981 <a name="l3961"><span class="ln">3961 </span></a>
3982 <a name="l3962"><span class="ln">3962 </span></a>    <span class="s3">def </span><span class="s1">validate(self</span><span class="s3">, </span><span class="s1">validateTrace=</span><span class="s3">None</span><span class="s1">):</span>
3983 <a name="l3963"><span class="ln">3963 </span></a>        <span class="s1">tmp = (validateTrace </span><span class="s3">if </span><span class="s1">validateTrace </span><span class="s3">is not None else </span><span class="s1">[])[:] + [self]</span>
3984 <a name="l3964"><span class="ln">3964 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
3985 <a name="l3965"><span class="ln">3965 </span></a>            <span class="s1">e.validate(tmp)</span>
3986 <a name="l3966"><span class="ln">3966 </span></a>        <span class="s1">self.checkRecursion([])</span>
3987 <a name="l3967"><span class="ln">3967 </span></a>
3988 <a name="l3968"><span class="ln">3968 </span></a>    <span class="s3">def </span><span class="s1">copy(self):</span>
3989 <a name="l3969"><span class="ln">3969 </span></a>        <span class="s1">ret = super(ParseExpression</span><span class="s3">, </span><span class="s1">self).copy()</span>
3990 <a name="l3970"><span class="ln">3970 </span></a>        <span class="s1">ret.exprs = [e.copy() </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs]</span>
3991 <a name="l3971"><span class="ln">3971 </span></a>        <span class="s3">return </span><span class="s1">ret</span>
3992 <a name="l3972"><span class="ln">3972 </span></a>
3993 <a name="l3973"><span class="ln">3973 </span></a>    <span class="s3">def </span><span class="s1">_setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
3994 <a name="l3974"><span class="ln">3974 </span></a>        <span class="s3">if </span><span class="s1">__diag__.warn_ungrouped_named_tokens_in_collection:</span>
3995 <a name="l3975"><span class="ln">3975 </span></a>            <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
3996 <a name="l3976"><span class="ln">3976 </span></a>                <span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">ParserElement) </span><span class="s3">and </span><span class="s1">e.resultsName:</span>
3997 <a name="l3977"><span class="ln">3977 </span></a>                    <span class="s1">warnings.warn(</span><span class="s2">&quot;{0}: setting results name {1!r} on {2} expression &quot;</span>
3998 <a name="l3978"><span class="ln">3978 </span></a>                                  <span class="s2">&quot;collides with {3!r} on contained expression&quot;</span><span class="s1">.format(</span><span class="s2">&quot;warn_ungrouped_named_tokens_in_collection&quot;</span><span class="s3">,</span>
3999 <a name="l3979"><span class="ln">3979 </span></a>                                                                                       <span class="s1">name</span><span class="s3">,</span>
4000 <a name="l3980"><span class="ln">3980 </span></a>                                                                                       <span class="s1">type(self).__name__</span><span class="s3">,</span>
4001 <a name="l3981"><span class="ln">3981 </span></a>                                                                                       <span class="s1">e.resultsName)</span><span class="s3">,</span>
4002 <a name="l3982"><span class="ln">3982 </span></a>                                  <span class="s1">stacklevel=</span><span class="s4">3</span><span class="s1">)</span>
4003 <a name="l3983"><span class="ln">3983 </span></a>
4004 <a name="l3984"><span class="ln">3984 </span></a>        <span class="s3">return </span><span class="s1">super(ParseExpression</span><span class="s3">, </span><span class="s1">self)._setResultsName(name</span><span class="s3">, </span><span class="s1">listAllMatches)</span>
4005 <a name="l3985"><span class="ln">3985 </span></a>
4006 <a name="l3986"><span class="ln">3986 </span></a>
4007 <a name="l3987"><span class="ln">3987 </span></a><span class="s3">class </span><span class="s1">And(ParseExpression):</span>
4008 <a name="l3988"><span class="ln">3988 </span></a>    <span class="s5">&quot;&quot;&quot; 
4009 <a name="l3989"><span class="ln">3989 </span></a>    Requires all given :class:`ParseExpression` s to be found in the given order. 
4010 <a name="l3990"><span class="ln">3990 </span></a>    Expressions may be separated by whitespace. 
4011 <a name="l3991"><span class="ln">3991 </span></a>    May be constructed using the ``'+'`` operator. 
4012 <a name="l3992"><span class="ln">3992 </span></a>    May also be constructed using the ``'-'`` operator, which will 
4013 <a name="l3993"><span class="ln">3993 </span></a>    suppress backtracking. 
4014 <a name="l3994"><span class="ln">3994 </span></a> 
4015 <a name="l3995"><span class="ln">3995 </span></a>    Example:: 
4016 <a name="l3996"><span class="ln">3996 </span></a> 
4017 <a name="l3997"><span class="ln">3997 </span></a>        integer = Word(nums) 
4018 <a name="l3998"><span class="ln">3998 </span></a>        name_expr = OneOrMore(Word(alphas)) 
4019 <a name="l3999"><span class="ln">3999 </span></a> 
4020 <a name="l4000"><span class="ln">4000 </span></a>        expr = And([integer(&quot;id&quot;), name_expr(&quot;name&quot;), integer(&quot;age&quot;)]) 
4021 <a name="l4001"><span class="ln">4001 </span></a>        # more easily written as: 
4022 <a name="l4002"><span class="ln">4002 </span></a>        expr = integer(&quot;id&quot;) + name_expr(&quot;name&quot;) + integer(&quot;age&quot;) 
4023 <a name="l4003"><span class="ln">4003 </span></a>    &quot;&quot;&quot;</span>
4024 <a name="l4004"><span class="ln">4004 </span></a>
4025 <a name="l4005"><span class="ln">4005 </span></a>    <span class="s3">class </span><span class="s1">_ErrorStop(Empty):</span>
4026 <a name="l4006"><span class="ln">4006 </span></a>        <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">*args</span><span class="s3">, </span><span class="s1">**kwargs):</span>
4027 <a name="l4007"><span class="ln">4007 </span></a>            <span class="s1">super(And._ErrorStop</span><span class="s3">, </span><span class="s1">self).__init__(*args</span><span class="s3">, </span><span class="s1">**kwargs)</span>
4028 <a name="l4008"><span class="ln">4008 </span></a>            <span class="s1">self.name = </span><span class="s2">'-'</span>
4029 <a name="l4009"><span class="ln">4009 </span></a>            <span class="s1">self.leaveWhitespace()</span>
4030 <a name="l4010"><span class="ln">4010 </span></a>
4031 <a name="l4011"><span class="ln">4011 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">exprs</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">True</span><span class="s1">):</span>
4032 <a name="l4012"><span class="ln">4012 </span></a>        <span class="s1">exprs = list(exprs)</span>
4033 <a name="l4013"><span class="ln">4013 </span></a>        <span class="s3">if </span><span class="s1">exprs </span><span class="s3">and </span><span class="s1">Ellipsis </span><span class="s3">in </span><span class="s1">exprs:</span>
4034 <a name="l4014"><span class="ln">4014 </span></a>            <span class="s1">tmp = []</span>
4035 <a name="l4015"><span class="ln">4015 </span></a>            <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">expr </span><span class="s3">in </span><span class="s1">enumerate(exprs):</span>
4036 <a name="l4016"><span class="ln">4016 </span></a>                <span class="s3">if </span><span class="s1">expr </span><span class="s3">is </span><span class="s1">Ellipsis:</span>
4037 <a name="l4017"><span class="ln">4017 </span></a>                    <span class="s3">if </span><span class="s1">i &lt; len(exprs) - </span><span class="s4">1</span><span class="s1">:</span>
4038 <a name="l4018"><span class="ln">4018 </span></a>                        <span class="s1">skipto_arg = (Empty() + exprs[i + </span><span class="s4">1</span><span class="s1">]).exprs[-</span><span class="s4">1</span><span class="s1">]</span>
4039 <a name="l4019"><span class="ln">4019 </span></a>                        <span class="s1">tmp.append(SkipTo(skipto_arg)(</span><span class="s2">&quot;_skipped*&quot;</span><span class="s1">))</span>
4040 <a name="l4020"><span class="ln">4020 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
4041 <a name="l4021"><span class="ln">4021 </span></a>                        <span class="s3">raise </span><span class="s1">Exception(</span><span class="s2">&quot;cannot construct And with sequence ending in ...&quot;</span><span class="s1">)</span>
4042 <a name="l4022"><span class="ln">4022 </span></a>                <span class="s3">else</span><span class="s1">:</span>
4043 <a name="l4023"><span class="ln">4023 </span></a>                    <span class="s1">tmp.append(expr)</span>
4044 <a name="l4024"><span class="ln">4024 </span></a>            <span class="s1">exprs[:] = tmp</span>
4045 <a name="l4025"><span class="ln">4025 </span></a>        <span class="s1">super(And</span><span class="s3">, </span><span class="s1">self).__init__(exprs</span><span class="s3">, </span><span class="s1">savelist)</span>
4046 <a name="l4026"><span class="ln">4026 </span></a>        <span class="s1">self.mayReturnEmpty = all(e.mayReturnEmpty </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4047 <a name="l4027"><span class="ln">4027 </span></a>        <span class="s1">self.setWhitespaceChars(self.exprs[</span><span class="s4">0</span><span class="s1">].whiteChars)</span>
4048 <a name="l4028"><span class="ln">4028 </span></a>        <span class="s1">self.skipWhitespace = self.exprs[</span><span class="s4">0</span><span class="s1">].skipWhitespace</span>
4049 <a name="l4029"><span class="ln">4029 </span></a>        <span class="s1">self.callPreparse = </span><span class="s3">True</span>
4050 <a name="l4030"><span class="ln">4030 </span></a>
4051 <a name="l4031"><span class="ln">4031 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
4052 <a name="l4032"><span class="ln">4032 </span></a>        <span class="s0"># collapse any _PendingSkip's</span>
4053 <a name="l4033"><span class="ln">4033 </span></a>        <span class="s3">if </span><span class="s1">self.exprs:</span>
4054 <a name="l4034"><span class="ln">4034 </span></a>            <span class="s3">if </span><span class="s1">any(isinstance(e</span><span class="s3">, </span><span class="s1">ParseExpression) </span><span class="s3">and </span><span class="s1">e.exprs </span><span class="s3">and </span><span class="s1">isinstance(e.exprs[-</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">_PendingSkip)</span>
4055 <a name="l4035"><span class="ln">4035 </span></a>                   <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs[:-</span><span class="s4">1</span><span class="s1">]):</span>
4056 <a name="l4036"><span class="ln">4036 </span></a>                <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">e </span><span class="s3">in </span><span class="s1">enumerate(self.exprs[:-</span><span class="s4">1</span><span class="s1">]):</span>
4057 <a name="l4037"><span class="ln">4037 </span></a>                    <span class="s3">if </span><span class="s1">e </span><span class="s3">is None</span><span class="s1">:</span>
4058 <a name="l4038"><span class="ln">4038 </span></a>                        <span class="s3">continue</span>
4059 <a name="l4039"><span class="ln">4039 </span></a>                    <span class="s3">if </span><span class="s1">(isinstance(e</span><span class="s3">, </span><span class="s1">ParseExpression)</span>
4060 <a name="l4040"><span class="ln">4040 </span></a>                            <span class="s3">and </span><span class="s1">e.exprs </span><span class="s3">and </span><span class="s1">isinstance(e.exprs[-</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">_PendingSkip)):</span>
4061 <a name="l4041"><span class="ln">4041 </span></a>                        <span class="s1">e.exprs[-</span><span class="s4">1</span><span class="s1">] = e.exprs[-</span><span class="s4">1</span><span class="s1">] + self.exprs[i + </span><span class="s4">1</span><span class="s1">]</span>
4062 <a name="l4042"><span class="ln">4042 </span></a>                        <span class="s1">self.exprs[i + </span><span class="s4">1</span><span class="s1">] = </span><span class="s3">None</span>
4063 <a name="l4043"><span class="ln">4043 </span></a>                <span class="s1">self.exprs = [e </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">e </span><span class="s3">is not None</span><span class="s1">]</span>
4064 <a name="l4044"><span class="ln">4044 </span></a>
4065 <a name="l4045"><span class="ln">4045 </span></a>        <span class="s1">super(And</span><span class="s3">, </span><span class="s1">self).streamline()</span>
4066 <a name="l4046"><span class="ln">4046 </span></a>        <span class="s1">self.mayReturnEmpty = all(e.mayReturnEmpty </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4067 <a name="l4047"><span class="ln">4047 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4068 <a name="l4048"><span class="ln">4048 </span></a>
4069 <a name="l4049"><span class="ln">4049 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4070 <a name="l4050"><span class="ln">4050 </span></a>        <span class="s0"># pass False as last arg to _parse for first element, since we already</span>
4071 <a name="l4051"><span class="ln">4051 </span></a>        <span class="s0"># pre-parsed the string as part of our And pre-parsing</span>
4072 <a name="l4052"><span class="ln">4052 </span></a>        <span class="s1">loc</span><span class="s3">, </span><span class="s1">resultlist = self.exprs[</span><span class="s4">0</span><span class="s1">]._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
4073 <a name="l4053"><span class="ln">4053 </span></a>        <span class="s1">errorStop = </span><span class="s3">False</span>
4074 <a name="l4054"><span class="ln">4054 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs[</span><span class="s4">1</span><span class="s1">:]:</span>
4075 <a name="l4055"><span class="ln">4055 </span></a>            <span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">And._ErrorStop):</span>
4076 <a name="l4056"><span class="ln">4056 </span></a>                <span class="s1">errorStop = </span><span class="s3">True</span>
4077 <a name="l4057"><span class="ln">4057 </span></a>                <span class="s3">continue</span>
4078 <a name="l4058"><span class="ln">4058 </span></a>            <span class="s3">if </span><span class="s1">errorStop:</span>
4079 <a name="l4059"><span class="ln">4059 </span></a>                <span class="s3">try</span><span class="s1">:</span>
4080 <a name="l4060"><span class="ln">4060 </span></a>                    <span class="s1">loc</span><span class="s3">, </span><span class="s1">exprtokens = e._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4081 <a name="l4061"><span class="ln">4061 </span></a>                <span class="s3">except </span><span class="s1">ParseSyntaxException:</span>
4082 <a name="l4062"><span class="ln">4062 </span></a>                    <span class="s3">raise</span>
4083 <a name="l4063"><span class="ln">4063 </span></a>                <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">pe:</span>
4084 <a name="l4064"><span class="ln">4064 </span></a>                    <span class="s1">pe.__traceback__ = </span><span class="s3">None</span>
4085 <a name="l4065"><span class="ln">4065 </span></a>                    <span class="s3">raise </span><span class="s1">ParseSyntaxException._from_exception(pe)</span>
4086 <a name="l4066"><span class="ln">4066 </span></a>                <span class="s3">except </span><span class="s1">IndexError:</span>
4087 <a name="l4067"><span class="ln">4067 </span></a>                    <span class="s3">raise </span><span class="s1">ParseSyntaxException(instring</span><span class="s3">, </span><span class="s1">len(instring)</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
4088 <a name="l4068"><span class="ln">4068 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4089 <a name="l4069"><span class="ln">4069 </span></a>                <span class="s1">loc</span><span class="s3">, </span><span class="s1">exprtokens = e._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4090 <a name="l4070"><span class="ln">4070 </span></a>            <span class="s3">if </span><span class="s1">exprtokens </span><span class="s3">or </span><span class="s1">exprtokens.haskeys():</span>
4091 <a name="l4071"><span class="ln">4071 </span></a>                <span class="s1">resultlist += exprtokens</span>
4092 <a name="l4072"><span class="ln">4072 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">resultlist</span>
4093 <a name="l4073"><span class="ln">4073 </span></a>
4094 <a name="l4074"><span class="ln">4074 </span></a>    <span class="s3">def </span><span class="s1">__iadd__(self</span><span class="s3">, </span><span class="s1">other):</span>
4095 <a name="l4075"><span class="ln">4075 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
4096 <a name="l4076"><span class="ln">4076 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
4097 <a name="l4077"><span class="ln">4077 </span></a>        <span class="s3">return </span><span class="s1">self.append(other)  </span><span class="s0"># And([self, other])</span>
4098 <a name="l4078"><span class="ln">4078 </span></a>
4099 <a name="l4079"><span class="ln">4079 </span></a>    <span class="s3">def </span><span class="s1">checkRecursion(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
4100 <a name="l4080"><span class="ln">4080 </span></a>        <span class="s1">subRecCheckList = parseElementList[:] + [self]</span>
4101 <a name="l4081"><span class="ln">4081 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
4102 <a name="l4082"><span class="ln">4082 </span></a>            <span class="s1">e.checkRecursion(subRecCheckList)</span>
4103 <a name="l4083"><span class="ln">4083 </span></a>            <span class="s3">if not </span><span class="s1">e.mayReturnEmpty:</span>
4104 <a name="l4084"><span class="ln">4084 </span></a>                <span class="s3">break</span>
4105 <a name="l4085"><span class="ln">4085 </span></a>
4106 <a name="l4086"><span class="ln">4086 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4107 <a name="l4087"><span class="ln">4087 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4108 <a name="l4088"><span class="ln">4088 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4109 <a name="l4089"><span class="ln">4089 </span></a>
4110 <a name="l4090"><span class="ln">4090 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4111 <a name="l4091"><span class="ln">4091 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;{&quot; </span><span class="s1">+ </span><span class="s2">&quot; &quot;</span><span class="s1">.join(_ustr(e) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs) + </span><span class="s2">&quot;}&quot;</span>
4112 <a name="l4092"><span class="ln">4092 </span></a>
4113 <a name="l4093"><span class="ln">4093 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4114 <a name="l4094"><span class="ln">4094 </span></a>
4115 <a name="l4095"><span class="ln">4095 </span></a>
4116 <a name="l4096"><span class="ln">4096 </span></a><span class="s3">class </span><span class="s1">Or(ParseExpression):</span>
4117 <a name="l4097"><span class="ln">4097 </span></a>    <span class="s5">&quot;&quot;&quot;Requires that at least one :class:`ParseExpression` is found. If 
4118 <a name="l4098"><span class="ln">4098 </span></a>    two expressions match, the expression that matches the longest 
4119 <a name="l4099"><span class="ln">4099 </span></a>    string will be used. May be constructed using the ``'^'`` 
4120 <a name="l4100"><span class="ln">4100 </span></a>    operator. 
4121 <a name="l4101"><span class="ln">4101 </span></a> 
4122 <a name="l4102"><span class="ln">4102 </span></a>    Example:: 
4123 <a name="l4103"><span class="ln">4103 </span></a> 
4124 <a name="l4104"><span class="ln">4104 </span></a>        # construct Or using '^' operator 
4125 <a name="l4105"><span class="ln">4105 </span></a> 
4126 <a name="l4106"><span class="ln">4106 </span></a>        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums)) 
4127 <a name="l4107"><span class="ln">4107 </span></a>        print(number.searchString(&quot;123 3.1416 789&quot;)) 
4128 <a name="l4108"><span class="ln">4108 </span></a> 
4129 <a name="l4109"><span class="ln">4109 </span></a>    prints:: 
4130 <a name="l4110"><span class="ln">4110 </span></a> 
4131 <a name="l4111"><span class="ln">4111 </span></a>        [['123'], ['3.1416'], ['789']] 
4132 <a name="l4112"><span class="ln">4112 </span></a>    &quot;&quot;&quot;</span>
4133 <a name="l4113"><span class="ln">4113 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">exprs</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">):</span>
4134 <a name="l4114"><span class="ln">4114 </span></a>        <span class="s1">super(Or</span><span class="s3">, </span><span class="s1">self).__init__(exprs</span><span class="s3">, </span><span class="s1">savelist)</span>
4135 <a name="l4115"><span class="ln">4115 </span></a>        <span class="s3">if </span><span class="s1">self.exprs:</span>
4136 <a name="l4116"><span class="ln">4116 </span></a>            <span class="s1">self.mayReturnEmpty = any(e.mayReturnEmpty </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4137 <a name="l4117"><span class="ln">4117 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4138 <a name="l4118"><span class="ln">4118 </span></a>            <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4139 <a name="l4119"><span class="ln">4119 </span></a>
4140 <a name="l4120"><span class="ln">4120 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
4141 <a name="l4121"><span class="ln">4121 </span></a>        <span class="s1">super(Or</span><span class="s3">, </span><span class="s1">self).streamline()</span>
4142 <a name="l4122"><span class="ln">4122 </span></a>        <span class="s3">if </span><span class="s1">__compat__.collect_all_And_tokens:</span>
4143 <a name="l4123"><span class="ln">4123 </span></a>            <span class="s1">self.saveAsList = any(e.saveAsList </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4144 <a name="l4124"><span class="ln">4124 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4145 <a name="l4125"><span class="ln">4125 </span></a>
4146 <a name="l4126"><span class="ln">4126 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4147 <a name="l4127"><span class="ln">4127 </span></a>        <span class="s1">maxExcLoc = -</span><span class="s4">1</span>
4148 <a name="l4128"><span class="ln">4128 </span></a>        <span class="s1">maxException = </span><span class="s3">None</span>
4149 <a name="l4129"><span class="ln">4129 </span></a>        <span class="s1">matches = []</span>
4150 <a name="l4130"><span class="ln">4130 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
4151 <a name="l4131"><span class="ln">4131 </span></a>            <span class="s3">try</span><span class="s1">:</span>
4152 <a name="l4132"><span class="ln">4132 </span></a>                <span class="s1">loc2 = e.tryParse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
4153 <a name="l4133"><span class="ln">4133 </span></a>            <span class="s3">except </span><span class="s1">ParseException </span><span class="s3">as </span><span class="s1">err:</span>
4154 <a name="l4134"><span class="ln">4134 </span></a>                <span class="s1">err.__traceback__ = </span><span class="s3">None</span>
4155 <a name="l4135"><span class="ln">4135 </span></a>                <span class="s3">if </span><span class="s1">err.loc &gt; maxExcLoc:</span>
4156 <a name="l4136"><span class="ln">4136 </span></a>                    <span class="s1">maxException = err</span>
4157 <a name="l4137"><span class="ln">4137 </span></a>                    <span class="s1">maxExcLoc = err.loc</span>
4158 <a name="l4138"><span class="ln">4138 </span></a>            <span class="s3">except </span><span class="s1">IndexError:</span>
4159 <a name="l4139"><span class="ln">4139 </span></a>                <span class="s3">if </span><span class="s1">len(instring) &gt; maxExcLoc:</span>
4160 <a name="l4140"><span class="ln">4140 </span></a>                    <span class="s1">maxException = ParseException(instring</span><span class="s3">, </span><span class="s1">len(instring)</span><span class="s3">, </span><span class="s1">e.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
4161 <a name="l4141"><span class="ln">4141 </span></a>                    <span class="s1">maxExcLoc = len(instring)</span>
4162 <a name="l4142"><span class="ln">4142 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4163 <a name="l4143"><span class="ln">4143 </span></a>                <span class="s0"># save match among all matches, to retry longest to shortest</span>
4164 <a name="l4144"><span class="ln">4144 </span></a>                <span class="s1">matches.append((loc2</span><span class="s3">, </span><span class="s1">e))</span>
4165 <a name="l4145"><span class="ln">4145 </span></a>
4166 <a name="l4146"><span class="ln">4146 </span></a>        <span class="s3">if </span><span class="s1">matches:</span>
4167 <a name="l4147"><span class="ln">4147 </span></a>            <span class="s0"># re-evaluate all matches in descending order of length of match, in case attached actions</span>
4168 <a name="l4148"><span class="ln">4148 </span></a>            <span class="s0"># might change whether or how much they match of the input.</span>
4169 <a name="l4149"><span class="ln">4149 </span></a>            <span class="s1">matches.sort(key=itemgetter(</span><span class="s4">0</span><span class="s1">)</span><span class="s3">, </span><span class="s1">reverse=</span><span class="s3">True</span><span class="s1">)</span>
4170 <a name="l4150"><span class="ln">4150 </span></a>
4171 <a name="l4151"><span class="ln">4151 </span></a>            <span class="s3">if not </span><span class="s1">doActions:</span>
4172 <a name="l4152"><span class="ln">4152 </span></a>                <span class="s0"># no further conditions or parse actions to change the selection of</span>
4173 <a name="l4153"><span class="ln">4153 </span></a>                <span class="s0"># alternative, so the first match will be the best match</span>
4174 <a name="l4154"><span class="ln">4154 </span></a>                <span class="s1">best_expr = matches[</span><span class="s4">0</span><span class="s1">][</span><span class="s4">1</span><span class="s1">]</span>
4175 <a name="l4155"><span class="ln">4155 </span></a>                <span class="s3">return </span><span class="s1">best_expr._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4176 <a name="l4156"><span class="ln">4156 </span></a>
4177 <a name="l4157"><span class="ln">4157 </span></a>            <span class="s1">longest = -</span><span class="s4">1</span><span class="s3">, None</span>
4178 <a name="l4158"><span class="ln">4158 </span></a>            <span class="s3">for </span><span class="s1">loc1</span><span class="s3">, </span><span class="s1">expr1 </span><span class="s3">in </span><span class="s1">matches:</span>
4179 <a name="l4159"><span class="ln">4159 </span></a>                <span class="s3">if </span><span class="s1">loc1 &lt;= longest[</span><span class="s4">0</span><span class="s1">]:</span>
4180 <a name="l4160"><span class="ln">4160 </span></a>                    <span class="s0"># already have a longer match than this one will deliver, we are done</span>
4181 <a name="l4161"><span class="ln">4161 </span></a>                    <span class="s3">return </span><span class="s1">longest</span>
4182 <a name="l4162"><span class="ln">4162 </span></a>
4183 <a name="l4163"><span class="ln">4163 </span></a>                <span class="s3">try</span><span class="s1">:</span>
4184 <a name="l4164"><span class="ln">4164 </span></a>                    <span class="s1">loc2</span><span class="s3">, </span><span class="s1">toks = expr1._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4185 <a name="l4165"><span class="ln">4165 </span></a>                <span class="s3">except </span><span class="s1">ParseException </span><span class="s3">as </span><span class="s1">err:</span>
4186 <a name="l4166"><span class="ln">4166 </span></a>                    <span class="s1">err.__traceback__ = </span><span class="s3">None</span>
4187 <a name="l4167"><span class="ln">4167 </span></a>                    <span class="s3">if </span><span class="s1">err.loc &gt; maxExcLoc:</span>
4188 <a name="l4168"><span class="ln">4168 </span></a>                        <span class="s1">maxException = err</span>
4189 <a name="l4169"><span class="ln">4169 </span></a>                        <span class="s1">maxExcLoc = err.loc</span>
4190 <a name="l4170"><span class="ln">4170 </span></a>                <span class="s3">else</span><span class="s1">:</span>
4191 <a name="l4171"><span class="ln">4171 </span></a>                    <span class="s3">if </span><span class="s1">loc2 &gt;= loc1:</span>
4192 <a name="l4172"><span class="ln">4172 </span></a>                        <span class="s3">return </span><span class="s1">loc2</span><span class="s3">, </span><span class="s1">toks</span>
4193 <a name="l4173"><span class="ln">4173 </span></a>                    <span class="s0"># didn't match as much as before</span>
4194 <a name="l4174"><span class="ln">4174 </span></a>                    <span class="s3">elif </span><span class="s1">loc2 &gt; longest[</span><span class="s4">0</span><span class="s1">]:</span>
4195 <a name="l4175"><span class="ln">4175 </span></a>                        <span class="s1">longest = loc2</span><span class="s3">, </span><span class="s1">toks</span>
4196 <a name="l4176"><span class="ln">4176 </span></a>
4197 <a name="l4177"><span class="ln">4177 </span></a>            <span class="s3">if </span><span class="s1">longest != (-</span><span class="s4">1</span><span class="s3">, None</span><span class="s1">):</span>
4198 <a name="l4178"><span class="ln">4178 </span></a>                <span class="s3">return </span><span class="s1">longest</span>
4199 <a name="l4179"><span class="ln">4179 </span></a>
4200 <a name="l4180"><span class="ln">4180 </span></a>        <span class="s3">if </span><span class="s1">maxException </span><span class="s3">is not None</span><span class="s1">:</span>
4201 <a name="l4181"><span class="ln">4181 </span></a>            <span class="s1">maxException.msg = self.errmsg</span>
4202 <a name="l4182"><span class="ln">4182 </span></a>            <span class="s3">raise </span><span class="s1">maxException</span>
4203 <a name="l4183"><span class="ln">4183 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4204 <a name="l4184"><span class="ln">4184 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s2">&quot;no defined alternatives to match&quot;</span><span class="s3">, </span><span class="s1">self)</span>
4205 <a name="l4185"><span class="ln">4185 </span></a>
4206 <a name="l4186"><span class="ln">4186 </span></a>
4207 <a name="l4187"><span class="ln">4187 </span></a>    <span class="s3">def </span><span class="s1">__ixor__(self</span><span class="s3">, </span><span class="s1">other):</span>
4208 <a name="l4188"><span class="ln">4188 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
4209 <a name="l4189"><span class="ln">4189 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
4210 <a name="l4190"><span class="ln">4190 </span></a>        <span class="s3">return </span><span class="s1">self.append(other)  </span><span class="s0"># Or([self, other])</span>
4211 <a name="l4191"><span class="ln">4191 </span></a>
4212 <a name="l4192"><span class="ln">4192 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4213 <a name="l4193"><span class="ln">4193 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4214 <a name="l4194"><span class="ln">4194 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4215 <a name="l4195"><span class="ln">4195 </span></a>
4216 <a name="l4196"><span class="ln">4196 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4217 <a name="l4197"><span class="ln">4197 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;{&quot; </span><span class="s1">+ </span><span class="s2">&quot; ^ &quot;</span><span class="s1">.join(_ustr(e) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs) + </span><span class="s2">&quot;}&quot;</span>
4218 <a name="l4198"><span class="ln">4198 </span></a>
4219 <a name="l4199"><span class="ln">4199 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4220 <a name="l4200"><span class="ln">4200 </span></a>
4221 <a name="l4201"><span class="ln">4201 </span></a>    <span class="s3">def </span><span class="s1">checkRecursion(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
4222 <a name="l4202"><span class="ln">4202 </span></a>        <span class="s1">subRecCheckList = parseElementList[:] + [self]</span>
4223 <a name="l4203"><span class="ln">4203 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
4224 <a name="l4204"><span class="ln">4204 </span></a>            <span class="s1">e.checkRecursion(subRecCheckList)</span>
4225 <a name="l4205"><span class="ln">4205 </span></a>
4226 <a name="l4206"><span class="ln">4206 </span></a>    <span class="s3">def </span><span class="s1">_setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
4227 <a name="l4207"><span class="ln">4207 </span></a>        <span class="s3">if </span><span class="s1">(</span><span class="s3">not </span><span class="s1">__compat__.collect_all_And_tokens</span>
4228 <a name="l4208"><span class="ln">4208 </span></a>                <span class="s3">and </span><span class="s1">__diag__.warn_multiple_tokens_in_named_alternation):</span>
4229 <a name="l4209"><span class="ln">4209 </span></a>            <span class="s3">if </span><span class="s1">any(isinstance(e</span><span class="s3">, </span><span class="s1">And) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs):</span>
4230 <a name="l4210"><span class="ln">4210 </span></a>                <span class="s1">warnings.warn(</span><span class="s2">&quot;{0}: setting results name {1!r} on {2} expression &quot;</span>
4231 <a name="l4211"><span class="ln">4211 </span></a>                              <span class="s2">&quot;may only return a single token for an And alternative, &quot;</span>
4232 <a name="l4212"><span class="ln">4212 </span></a>                              <span class="s2">&quot;in future will return the full list of tokens&quot;</span><span class="s1">.format(</span>
4233 <a name="l4213"><span class="ln">4213 </span></a>                    <span class="s2">&quot;warn_multiple_tokens_in_named_alternation&quot;</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">type(self).__name__)</span><span class="s3">,</span>
4234 <a name="l4214"><span class="ln">4214 </span></a>                    <span class="s1">stacklevel=</span><span class="s4">3</span><span class="s1">)</span>
4235 <a name="l4215"><span class="ln">4215 </span></a>
4236 <a name="l4216"><span class="ln">4216 </span></a>        <span class="s3">return </span><span class="s1">super(Or</span><span class="s3">, </span><span class="s1">self)._setResultsName(name</span><span class="s3">, </span><span class="s1">listAllMatches)</span>
4237 <a name="l4217"><span class="ln">4217 </span></a>
4238 <a name="l4218"><span class="ln">4218 </span></a>
4239 <a name="l4219"><span class="ln">4219 </span></a><span class="s3">class </span><span class="s1">MatchFirst(ParseExpression):</span>
4240 <a name="l4220"><span class="ln">4220 </span></a>    <span class="s5">&quot;&quot;&quot;Requires that at least one :class:`ParseExpression` is found. If 
4241 <a name="l4221"><span class="ln">4221 </span></a>    two expressions match, the first one listed is the one that will 
4242 <a name="l4222"><span class="ln">4222 </span></a>    match. May be constructed using the ``'|'`` operator. 
4243 <a name="l4223"><span class="ln">4223 </span></a> 
4244 <a name="l4224"><span class="ln">4224 </span></a>    Example:: 
4245 <a name="l4225"><span class="ln">4225 </span></a> 
4246 <a name="l4226"><span class="ln">4226 </span></a>        # construct MatchFirst using '|' operator 
4247 <a name="l4227"><span class="ln">4227 </span></a> 
4248 <a name="l4228"><span class="ln">4228 </span></a>        # watch the order of expressions to match 
4249 <a name="l4229"><span class="ln">4229 </span></a>        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums)) 
4250 <a name="l4230"><span class="ln">4230 </span></a>        print(number.searchString(&quot;123 3.1416 789&quot;)) #  Fail! -&gt; [['123'], ['3'], ['1416'], ['789']] 
4251 <a name="l4231"><span class="ln">4231 </span></a> 
4252 <a name="l4232"><span class="ln">4232 </span></a>        # put more selective expression first 
4253 <a name="l4233"><span class="ln">4233 </span></a>        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums) 
4254 <a name="l4234"><span class="ln">4234 </span></a>        print(number.searchString(&quot;123 3.1416 789&quot;)) #  Better -&gt; [['123'], ['3.1416'], ['789']] 
4255 <a name="l4235"><span class="ln">4235 </span></a>    &quot;&quot;&quot;</span>
4256 <a name="l4236"><span class="ln">4236 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">exprs</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">):</span>
4257 <a name="l4237"><span class="ln">4237 </span></a>        <span class="s1">super(MatchFirst</span><span class="s3">, </span><span class="s1">self).__init__(exprs</span><span class="s3">, </span><span class="s1">savelist)</span>
4258 <a name="l4238"><span class="ln">4238 </span></a>        <span class="s3">if </span><span class="s1">self.exprs:</span>
4259 <a name="l4239"><span class="ln">4239 </span></a>            <span class="s1">self.mayReturnEmpty = any(e.mayReturnEmpty </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4260 <a name="l4240"><span class="ln">4240 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4261 <a name="l4241"><span class="ln">4241 </span></a>            <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4262 <a name="l4242"><span class="ln">4242 </span></a>
4263 <a name="l4243"><span class="ln">4243 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
4264 <a name="l4244"><span class="ln">4244 </span></a>        <span class="s1">super(MatchFirst</span><span class="s3">, </span><span class="s1">self).streamline()</span>
4265 <a name="l4245"><span class="ln">4245 </span></a>        <span class="s3">if </span><span class="s1">__compat__.collect_all_And_tokens:</span>
4266 <a name="l4246"><span class="ln">4246 </span></a>            <span class="s1">self.saveAsList = any(e.saveAsList </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4267 <a name="l4247"><span class="ln">4247 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4268 <a name="l4248"><span class="ln">4248 </span></a>
4269 <a name="l4249"><span class="ln">4249 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4270 <a name="l4250"><span class="ln">4250 </span></a>        <span class="s1">maxExcLoc = -</span><span class="s4">1</span>
4271 <a name="l4251"><span class="ln">4251 </span></a>        <span class="s1">maxException = </span><span class="s3">None</span>
4272 <a name="l4252"><span class="ln">4252 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
4273 <a name="l4253"><span class="ln">4253 </span></a>            <span class="s3">try</span><span class="s1">:</span>
4274 <a name="l4254"><span class="ln">4254 </span></a>                <span class="s1">ret = e._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4275 <a name="l4255"><span class="ln">4255 </span></a>                <span class="s3">return </span><span class="s1">ret</span>
4276 <a name="l4256"><span class="ln">4256 </span></a>            <span class="s3">except </span><span class="s1">ParseException </span><span class="s3">as </span><span class="s1">err:</span>
4277 <a name="l4257"><span class="ln">4257 </span></a>                <span class="s3">if </span><span class="s1">err.loc &gt; maxExcLoc:</span>
4278 <a name="l4258"><span class="ln">4258 </span></a>                    <span class="s1">maxException = err</span>
4279 <a name="l4259"><span class="ln">4259 </span></a>                    <span class="s1">maxExcLoc = err.loc</span>
4280 <a name="l4260"><span class="ln">4260 </span></a>            <span class="s3">except </span><span class="s1">IndexError:</span>
4281 <a name="l4261"><span class="ln">4261 </span></a>                <span class="s3">if </span><span class="s1">len(instring) &gt; maxExcLoc:</span>
4282 <a name="l4262"><span class="ln">4262 </span></a>                    <span class="s1">maxException = ParseException(instring</span><span class="s3">, </span><span class="s1">len(instring)</span><span class="s3">, </span><span class="s1">e.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
4283 <a name="l4263"><span class="ln">4263 </span></a>                    <span class="s1">maxExcLoc = len(instring)</span>
4284 <a name="l4264"><span class="ln">4264 </span></a>
4285 <a name="l4265"><span class="ln">4265 </span></a>        <span class="s0"># only got here if no expression matched, raise exception for match that made it the furthest</span>
4286 <a name="l4266"><span class="ln">4266 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4287 <a name="l4267"><span class="ln">4267 </span></a>            <span class="s3">if </span><span class="s1">maxException </span><span class="s3">is not None</span><span class="s1">:</span>
4288 <a name="l4268"><span class="ln">4268 </span></a>                <span class="s1">maxException.msg = self.errmsg</span>
4289 <a name="l4269"><span class="ln">4269 </span></a>                <span class="s3">raise </span><span class="s1">maxException</span>
4290 <a name="l4270"><span class="ln">4270 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4291 <a name="l4271"><span class="ln">4271 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s2">&quot;no defined alternatives to match&quot;</span><span class="s3">, </span><span class="s1">self)</span>
4292 <a name="l4272"><span class="ln">4272 </span></a>
4293 <a name="l4273"><span class="ln">4273 </span></a>    <span class="s3">def </span><span class="s1">__ior__(self</span><span class="s3">, </span><span class="s1">other):</span>
4294 <a name="l4274"><span class="ln">4274 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
4295 <a name="l4275"><span class="ln">4275 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
4296 <a name="l4276"><span class="ln">4276 </span></a>        <span class="s3">return </span><span class="s1">self.append(other)  </span><span class="s0"># MatchFirst([self, other])</span>
4297 <a name="l4277"><span class="ln">4277 </span></a>
4298 <a name="l4278"><span class="ln">4278 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4299 <a name="l4279"><span class="ln">4279 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4300 <a name="l4280"><span class="ln">4280 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4301 <a name="l4281"><span class="ln">4281 </span></a>
4302 <a name="l4282"><span class="ln">4282 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4303 <a name="l4283"><span class="ln">4283 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;{&quot; </span><span class="s1">+ </span><span class="s2">&quot; | &quot;</span><span class="s1">.join(_ustr(e) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs) + </span><span class="s2">&quot;}&quot;</span>
4304 <a name="l4284"><span class="ln">4284 </span></a>
4305 <a name="l4285"><span class="ln">4285 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4306 <a name="l4286"><span class="ln">4286 </span></a>
4307 <a name="l4287"><span class="ln">4287 </span></a>    <span class="s3">def </span><span class="s1">checkRecursion(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
4308 <a name="l4288"><span class="ln">4288 </span></a>        <span class="s1">subRecCheckList = parseElementList[:] + [self]</span>
4309 <a name="l4289"><span class="ln">4289 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
4310 <a name="l4290"><span class="ln">4290 </span></a>            <span class="s1">e.checkRecursion(subRecCheckList)</span>
4311 <a name="l4291"><span class="ln">4291 </span></a>
4312 <a name="l4292"><span class="ln">4292 </span></a>    <span class="s3">def </span><span class="s1">_setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
4313 <a name="l4293"><span class="ln">4293 </span></a>        <span class="s3">if </span><span class="s1">(</span><span class="s3">not </span><span class="s1">__compat__.collect_all_And_tokens</span>
4314 <a name="l4294"><span class="ln">4294 </span></a>                <span class="s3">and </span><span class="s1">__diag__.warn_multiple_tokens_in_named_alternation):</span>
4315 <a name="l4295"><span class="ln">4295 </span></a>            <span class="s3">if </span><span class="s1">any(isinstance(e</span><span class="s3">, </span><span class="s1">And) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs):</span>
4316 <a name="l4296"><span class="ln">4296 </span></a>                <span class="s1">warnings.warn(</span><span class="s2">&quot;{0}: setting results name {1!r} on {2} expression &quot;</span>
4317 <a name="l4297"><span class="ln">4297 </span></a>                              <span class="s2">&quot;may only return a single token for an And alternative, &quot;</span>
4318 <a name="l4298"><span class="ln">4298 </span></a>                              <span class="s2">&quot;in future will return the full list of tokens&quot;</span><span class="s1">.format(</span>
4319 <a name="l4299"><span class="ln">4299 </span></a>                    <span class="s2">&quot;warn_multiple_tokens_in_named_alternation&quot;</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">type(self).__name__)</span><span class="s3">,</span>
4320 <a name="l4300"><span class="ln">4300 </span></a>                    <span class="s1">stacklevel=</span><span class="s4">3</span><span class="s1">)</span>
4321 <a name="l4301"><span class="ln">4301 </span></a>
4322 <a name="l4302"><span class="ln">4302 </span></a>        <span class="s3">return </span><span class="s1">super(MatchFirst</span><span class="s3">, </span><span class="s1">self)._setResultsName(name</span><span class="s3">, </span><span class="s1">listAllMatches)</span>
4323 <a name="l4303"><span class="ln">4303 </span></a>
4324 <a name="l4304"><span class="ln">4304 </span></a>
4325 <a name="l4305"><span class="ln">4305 </span></a><span class="s3">class </span><span class="s1">Each(ParseExpression):</span>
4326 <a name="l4306"><span class="ln">4306 </span></a>    <span class="s5">&quot;&quot;&quot;Requires all given :class:`ParseExpression` s to be found, but in 
4327 <a name="l4307"><span class="ln">4307 </span></a>    any order. Expressions may be separated by whitespace. 
4328 <a name="l4308"><span class="ln">4308 </span></a> 
4329 <a name="l4309"><span class="ln">4309 </span></a>    May be constructed using the ``'&amp;'`` operator. 
4330 <a name="l4310"><span class="ln">4310 </span></a> 
4331 <a name="l4311"><span class="ln">4311 </span></a>    Example:: 
4332 <a name="l4312"><span class="ln">4312 </span></a> 
4333 <a name="l4313"><span class="ln">4313 </span></a>        color = oneOf(&quot;RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN&quot;) 
4334 <a name="l4314"><span class="ln">4314 </span></a>        shape_type = oneOf(&quot;SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON&quot;) 
4335 <a name="l4315"><span class="ln">4315 </span></a>        integer = Word(nums) 
4336 <a name="l4316"><span class="ln">4316 </span></a>        shape_attr = &quot;shape:&quot; + shape_type(&quot;shape&quot;) 
4337 <a name="l4317"><span class="ln">4317 </span></a>        posn_attr = &quot;posn:&quot; + Group(integer(&quot;x&quot;) + ',' + integer(&quot;y&quot;))(&quot;posn&quot;) 
4338 <a name="l4318"><span class="ln">4318 </span></a>        color_attr = &quot;color:&quot; + color(&quot;color&quot;) 
4339 <a name="l4319"><span class="ln">4319 </span></a>        size_attr = &quot;size:&quot; + integer(&quot;size&quot;) 
4340 <a name="l4320"><span class="ln">4320 </span></a> 
4341 <a name="l4321"><span class="ln">4321 </span></a>        # use Each (using operator '&amp;') to accept attributes in any order 
4342 <a name="l4322"><span class="ln">4322 </span></a>        # (shape and posn are required, color and size are optional) 
4343 <a name="l4323"><span class="ln">4323 </span></a>        shape_spec = shape_attr &amp; posn_attr &amp; Optional(color_attr) &amp; Optional(size_attr) 
4344 <a name="l4324"><span class="ln">4324 </span></a> 
4345 <a name="l4325"><span class="ln">4325 </span></a>        shape_spec.runTests(''' 
4346 <a name="l4326"><span class="ln">4326 </span></a>            shape: SQUARE color: BLACK posn: 100, 120 
4347 <a name="l4327"><span class="ln">4327 </span></a>            shape: CIRCLE size: 50 color: BLUE posn: 50,80 
4348 <a name="l4328"><span class="ln">4328 </span></a>            color:GREEN size:20 shape:TRIANGLE posn:20,40 
4349 <a name="l4329"><span class="ln">4329 </span></a>            ''' 
4350 <a name="l4330"><span class="ln">4330 </span></a>            ) 
4351 <a name="l4331"><span class="ln">4331 </span></a> 
4352 <a name="l4332"><span class="ln">4332 </span></a>    prints:: 
4353 <a name="l4333"><span class="ln">4333 </span></a> 
4354 <a name="l4334"><span class="ln">4334 </span></a>        shape: SQUARE color: BLACK posn: 100, 120 
4355 <a name="l4335"><span class="ln">4335 </span></a>        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']] 
4356 <a name="l4336"><span class="ln">4336 </span></a>        - color: BLACK 
4357 <a name="l4337"><span class="ln">4337 </span></a>        - posn: ['100', ',', '120'] 
4358 <a name="l4338"><span class="ln">4338 </span></a>          - x: 100 
4359 <a name="l4339"><span class="ln">4339 </span></a>          - y: 120 
4360 <a name="l4340"><span class="ln">4340 </span></a>        - shape: SQUARE 
4361 <a name="l4341"><span class="ln">4341 </span></a> 
4362 <a name="l4342"><span class="ln">4342 </span></a> 
4363 <a name="l4343"><span class="ln">4343 </span></a>        shape: CIRCLE size: 50 color: BLUE posn: 50,80 
4364 <a name="l4344"><span class="ln">4344 </span></a>        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']] 
4365 <a name="l4345"><span class="ln">4345 </span></a>        - color: BLUE 
4366 <a name="l4346"><span class="ln">4346 </span></a>        - posn: ['50', ',', '80'] 
4367 <a name="l4347"><span class="ln">4347 </span></a>          - x: 50 
4368 <a name="l4348"><span class="ln">4348 </span></a>          - y: 80 
4369 <a name="l4349"><span class="ln">4349 </span></a>        - shape: CIRCLE 
4370 <a name="l4350"><span class="ln">4350 </span></a>        - size: 50 
4371 <a name="l4351"><span class="ln">4351 </span></a> 
4372 <a name="l4352"><span class="ln">4352 </span></a> 
4373 <a name="l4353"><span class="ln">4353 </span></a>        color: GREEN size: 20 shape: TRIANGLE posn: 20,40 
4374 <a name="l4354"><span class="ln">4354 </span></a>        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']] 
4375 <a name="l4355"><span class="ln">4355 </span></a>        - color: GREEN 
4376 <a name="l4356"><span class="ln">4356 </span></a>        - posn: ['20', ',', '40'] 
4377 <a name="l4357"><span class="ln">4357 </span></a>          - x: 20 
4378 <a name="l4358"><span class="ln">4358 </span></a>          - y: 40 
4379 <a name="l4359"><span class="ln">4359 </span></a>        - shape: TRIANGLE 
4380 <a name="l4360"><span class="ln">4360 </span></a>        - size: 20 
4381 <a name="l4361"><span class="ln">4361 </span></a>    &quot;&quot;&quot;</span>
4382 <a name="l4362"><span class="ln">4362 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">exprs</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">True</span><span class="s1">):</span>
4383 <a name="l4363"><span class="ln">4363 </span></a>        <span class="s1">super(Each</span><span class="s3">, </span><span class="s1">self).__init__(exprs</span><span class="s3">, </span><span class="s1">savelist)</span>
4384 <a name="l4364"><span class="ln">4364 </span></a>        <span class="s1">self.mayReturnEmpty = all(e.mayReturnEmpty </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4385 <a name="l4365"><span class="ln">4365 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">True</span>
4386 <a name="l4366"><span class="ln">4366 </span></a>        <span class="s1">self.initExprGroups = </span><span class="s3">True</span>
4387 <a name="l4367"><span class="ln">4367 </span></a>        <span class="s1">self.saveAsList = </span><span class="s3">True</span>
4388 <a name="l4368"><span class="ln">4368 </span></a>
4389 <a name="l4369"><span class="ln">4369 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
4390 <a name="l4370"><span class="ln">4370 </span></a>        <span class="s1">super(Each</span><span class="s3">, </span><span class="s1">self).streamline()</span>
4391 <a name="l4371"><span class="ln">4371 </span></a>        <span class="s1">self.mayReturnEmpty = all(e.mayReturnEmpty </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs)</span>
4392 <a name="l4372"><span class="ln">4372 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4393 <a name="l4373"><span class="ln">4373 </span></a>
4394 <a name="l4374"><span class="ln">4374 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4395 <a name="l4375"><span class="ln">4375 </span></a>        <span class="s3">if </span><span class="s1">self.initExprGroups:</span>
4396 <a name="l4376"><span class="ln">4376 </span></a>            <span class="s1">self.opt1map = dict((id(e.expr)</span><span class="s3">, </span><span class="s1">e) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">Optional))</span>
4397 <a name="l4377"><span class="ln">4377 </span></a>            <span class="s1">opt1 = [e.expr </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">Optional)]</span>
4398 <a name="l4378"><span class="ln">4378 </span></a>            <span class="s1">opt2 = [e </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">e.mayReturnEmpty </span><span class="s3">and not </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">(Optional</span><span class="s3">, </span><span class="s1">Regex))]</span>
4399 <a name="l4379"><span class="ln">4379 </span></a>            <span class="s1">self.optionals = opt1 + opt2</span>
4400 <a name="l4380"><span class="ln">4380 </span></a>            <span class="s1">self.multioptionals = [e.expr </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">ZeroOrMore)]</span>
4401 <a name="l4381"><span class="ln">4381 </span></a>            <span class="s1">self.multirequired = [e.expr </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">OneOrMore)]</span>
4402 <a name="l4382"><span class="ln">4382 </span></a>            <span class="s1">self.required = [e </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if not </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">(Optional</span><span class="s3">, </span><span class="s1">ZeroOrMore</span><span class="s3">, </span><span class="s1">OneOrMore))]</span>
4403 <a name="l4383"><span class="ln">4383 </span></a>            <span class="s1">self.required += self.multirequired</span>
4404 <a name="l4384"><span class="ln">4384 </span></a>            <span class="s1">self.initExprGroups = </span><span class="s3">False</span>
4405 <a name="l4385"><span class="ln">4385 </span></a>        <span class="s1">tmpLoc = loc</span>
4406 <a name="l4386"><span class="ln">4386 </span></a>        <span class="s1">tmpReqd = self.required[:]</span>
4407 <a name="l4387"><span class="ln">4387 </span></a>        <span class="s1">tmpOpt  = self.optionals[:]</span>
4408 <a name="l4388"><span class="ln">4388 </span></a>        <span class="s1">matchOrder = []</span>
4409 <a name="l4389"><span class="ln">4389 </span></a>
4410 <a name="l4390"><span class="ln">4390 </span></a>        <span class="s1">keepMatching = </span><span class="s3">True</span>
4411 <a name="l4391"><span class="ln">4391 </span></a>        <span class="s3">while </span><span class="s1">keepMatching:</span>
4412 <a name="l4392"><span class="ln">4392 </span></a>            <span class="s1">tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired</span>
4413 <a name="l4393"><span class="ln">4393 </span></a>            <span class="s1">failed = []</span>
4414 <a name="l4394"><span class="ln">4394 </span></a>            <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">tmpExprs:</span>
4415 <a name="l4395"><span class="ln">4395 </span></a>                <span class="s3">try</span><span class="s1">:</span>
4416 <a name="l4396"><span class="ln">4396 </span></a>                    <span class="s1">tmpLoc = e.tryParse(instring</span><span class="s3">, </span><span class="s1">tmpLoc)</span>
4417 <a name="l4397"><span class="ln">4397 </span></a>                <span class="s3">except </span><span class="s1">ParseException:</span>
4418 <a name="l4398"><span class="ln">4398 </span></a>                    <span class="s1">failed.append(e)</span>
4419 <a name="l4399"><span class="ln">4399 </span></a>                <span class="s3">else</span><span class="s1">:</span>
4420 <a name="l4400"><span class="ln">4400 </span></a>                    <span class="s1">matchOrder.append(self.opt1map.get(id(e)</span><span class="s3">, </span><span class="s1">e))</span>
4421 <a name="l4401"><span class="ln">4401 </span></a>                    <span class="s3">if </span><span class="s1">e </span><span class="s3">in </span><span class="s1">tmpReqd:</span>
4422 <a name="l4402"><span class="ln">4402 </span></a>                        <span class="s1">tmpReqd.remove(e)</span>
4423 <a name="l4403"><span class="ln">4403 </span></a>                    <span class="s3">elif </span><span class="s1">e </span><span class="s3">in </span><span class="s1">tmpOpt:</span>
4424 <a name="l4404"><span class="ln">4404 </span></a>                        <span class="s1">tmpOpt.remove(e)</span>
4425 <a name="l4405"><span class="ln">4405 </span></a>            <span class="s3">if </span><span class="s1">len(failed) == len(tmpExprs):</span>
4426 <a name="l4406"><span class="ln">4406 </span></a>                <span class="s1">keepMatching = </span><span class="s3">False</span>
4427 <a name="l4407"><span class="ln">4407 </span></a>
4428 <a name="l4408"><span class="ln">4408 </span></a>        <span class="s3">if </span><span class="s1">tmpReqd:</span>
4429 <a name="l4409"><span class="ln">4409 </span></a>            <span class="s1">missing = </span><span class="s2">&quot;, &quot;</span><span class="s1">.join(_ustr(e) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">tmpReqd)</span>
4430 <a name="l4410"><span class="ln">4410 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s2">&quot;Missing one or more required elements (%s)&quot; </span><span class="s1">% missing)</span>
4431 <a name="l4411"><span class="ln">4411 </span></a>
4432 <a name="l4412"><span class="ln">4412 </span></a>        <span class="s0"># add any unmatched Optionals, in case they have default values defined</span>
4433 <a name="l4413"><span class="ln">4413 </span></a>        <span class="s1">matchOrder += [e </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs </span><span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">Optional) </span><span class="s3">and </span><span class="s1">e.expr </span><span class="s3">in </span><span class="s1">tmpOpt]</span>
4434 <a name="l4414"><span class="ln">4414 </span></a>
4435 <a name="l4415"><span class="ln">4415 </span></a>        <span class="s1">resultlist = []</span>
4436 <a name="l4416"><span class="ln">4416 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">matchOrder:</span>
4437 <a name="l4417"><span class="ln">4417 </span></a>            <span class="s1">loc</span><span class="s3">, </span><span class="s1">results = e._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4438 <a name="l4418"><span class="ln">4418 </span></a>            <span class="s1">resultlist.append(results)</span>
4439 <a name="l4419"><span class="ln">4419 </span></a>
4440 <a name="l4420"><span class="ln">4420 </span></a>        <span class="s1">finalResults = sum(resultlist</span><span class="s3">, </span><span class="s1">ParseResults([]))</span>
4441 <a name="l4421"><span class="ln">4421 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">finalResults</span>
4442 <a name="l4422"><span class="ln">4422 </span></a>
4443 <a name="l4423"><span class="ln">4423 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4444 <a name="l4424"><span class="ln">4424 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4445 <a name="l4425"><span class="ln">4425 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4446 <a name="l4426"><span class="ln">4426 </span></a>
4447 <a name="l4427"><span class="ln">4427 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4448 <a name="l4428"><span class="ln">4428 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;{&quot; </span><span class="s1">+ </span><span class="s2">&quot; &amp; &quot;</span><span class="s1">.join(_ustr(e) </span><span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs) + </span><span class="s2">&quot;}&quot;</span>
4449 <a name="l4429"><span class="ln">4429 </span></a>
4450 <a name="l4430"><span class="ln">4430 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4451 <a name="l4431"><span class="ln">4431 </span></a>
4452 <a name="l4432"><span class="ln">4432 </span></a>    <span class="s3">def </span><span class="s1">checkRecursion(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
4453 <a name="l4433"><span class="ln">4433 </span></a>        <span class="s1">subRecCheckList = parseElementList[:] + [self]</span>
4454 <a name="l4434"><span class="ln">4434 </span></a>        <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">self.exprs:</span>
4455 <a name="l4435"><span class="ln">4435 </span></a>            <span class="s1">e.checkRecursion(subRecCheckList)</span>
4456 <a name="l4436"><span class="ln">4436 </span></a>
4457 <a name="l4437"><span class="ln">4437 </span></a>
4458 <a name="l4438"><span class="ln">4438 </span></a><span class="s3">class </span><span class="s1">ParseElementEnhance(ParserElement):</span>
4459 <a name="l4439"><span class="ln">4439 </span></a>    <span class="s5">&quot;&quot;&quot;Abstract subclass of :class:`ParserElement`, for combining and 
4460 <a name="l4440"><span class="ln">4440 </span></a>    post-processing parsed tokens. 
4461 <a name="l4441"><span class="ln">4441 </span></a>    &quot;&quot;&quot;</span>
4462 <a name="l4442"><span class="ln">4442 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">):</span>
4463 <a name="l4443"><span class="ln">4443 </span></a>        <span class="s1">super(ParseElementEnhance</span><span class="s3">, </span><span class="s1">self).__init__(savelist)</span>
4464 <a name="l4444"><span class="ln">4444 </span></a>        <span class="s3">if </span><span class="s1">isinstance(expr</span><span class="s3">, </span><span class="s1">basestring):</span>
4465 <a name="l4445"><span class="ln">4445 </span></a>            <span class="s3">if </span><span class="s1">issubclass(self._literalStringClass</span><span class="s3">, </span><span class="s1">Token):</span>
4466 <a name="l4446"><span class="ln">4446 </span></a>                <span class="s1">expr = self._literalStringClass(expr)</span>
4467 <a name="l4447"><span class="ln">4447 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4468 <a name="l4448"><span class="ln">4448 </span></a>                <span class="s1">expr = self._literalStringClass(Literal(expr))</span>
4469 <a name="l4449"><span class="ln">4449 </span></a>        <span class="s1">self.expr = expr</span>
4470 <a name="l4450"><span class="ln">4450 </span></a>        <span class="s1">self.strRepr = </span><span class="s3">None</span>
4471 <a name="l4451"><span class="ln">4451 </span></a>        <span class="s3">if </span><span class="s1">expr </span><span class="s3">is not None</span><span class="s1">:</span>
4472 <a name="l4452"><span class="ln">4452 </span></a>            <span class="s1">self.mayIndexError = expr.mayIndexError</span>
4473 <a name="l4453"><span class="ln">4453 </span></a>            <span class="s1">self.mayReturnEmpty = expr.mayReturnEmpty</span>
4474 <a name="l4454"><span class="ln">4454 </span></a>            <span class="s1">self.setWhitespaceChars(expr.whiteChars)</span>
4475 <a name="l4455"><span class="ln">4455 </span></a>            <span class="s1">self.skipWhitespace = expr.skipWhitespace</span>
4476 <a name="l4456"><span class="ln">4456 </span></a>            <span class="s1">self.saveAsList = expr.saveAsList</span>
4477 <a name="l4457"><span class="ln">4457 </span></a>            <span class="s1">self.callPreparse = expr.callPreparse</span>
4478 <a name="l4458"><span class="ln">4458 </span></a>            <span class="s1">self.ignoreExprs.extend(expr.ignoreExprs)</span>
4479 <a name="l4459"><span class="ln">4459 </span></a>
4480 <a name="l4460"><span class="ln">4460 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4481 <a name="l4461"><span class="ln">4461 </span></a>        <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4482 <a name="l4462"><span class="ln">4462 </span></a>            <span class="s3">return </span><span class="s1">self.expr._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
4483 <a name="l4463"><span class="ln">4463 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4484 <a name="l4464"><span class="ln">4464 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(</span><span class="s2">&quot;&quot;</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
4485 <a name="l4465"><span class="ln">4465 </span></a>
4486 <a name="l4466"><span class="ln">4466 </span></a>    <span class="s3">def </span><span class="s1">leaveWhitespace(self):</span>
4487 <a name="l4467"><span class="ln">4467 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
4488 <a name="l4468"><span class="ln">4468 </span></a>        <span class="s1">self.expr = self.expr.copy()</span>
4489 <a name="l4469"><span class="ln">4469 </span></a>        <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4490 <a name="l4470"><span class="ln">4470 </span></a>            <span class="s1">self.expr.leaveWhitespace()</span>
4491 <a name="l4471"><span class="ln">4471 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4492 <a name="l4472"><span class="ln">4472 </span></a>
4493 <a name="l4473"><span class="ln">4473 </span></a>    <span class="s3">def </span><span class="s1">ignore(self</span><span class="s3">, </span><span class="s1">other):</span>
4494 <a name="l4474"><span class="ln">4474 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">Suppress):</span>
4495 <a name="l4475"><span class="ln">4475 </span></a>            <span class="s3">if </span><span class="s1">other </span><span class="s3">not in </span><span class="s1">self.ignoreExprs:</span>
4496 <a name="l4476"><span class="ln">4476 </span></a>                <span class="s1">super(ParseElementEnhance</span><span class="s3">, </span><span class="s1">self).ignore(other)</span>
4497 <a name="l4477"><span class="ln">4477 </span></a>                <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4498 <a name="l4478"><span class="ln">4478 </span></a>                    <span class="s1">self.expr.ignore(self.ignoreExprs[-</span><span class="s4">1</span><span class="s1">])</span>
4499 <a name="l4479"><span class="ln">4479 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4500 <a name="l4480"><span class="ln">4480 </span></a>            <span class="s1">super(ParseElementEnhance</span><span class="s3">, </span><span class="s1">self).ignore(other)</span>
4501 <a name="l4481"><span class="ln">4481 </span></a>            <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4502 <a name="l4482"><span class="ln">4482 </span></a>                <span class="s1">self.expr.ignore(self.ignoreExprs[-</span><span class="s4">1</span><span class="s1">])</span>
4503 <a name="l4483"><span class="ln">4483 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4504 <a name="l4484"><span class="ln">4484 </span></a>
4505 <a name="l4485"><span class="ln">4485 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
4506 <a name="l4486"><span class="ln">4486 </span></a>        <span class="s1">super(ParseElementEnhance</span><span class="s3">, </span><span class="s1">self).streamline()</span>
4507 <a name="l4487"><span class="ln">4487 </span></a>        <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4508 <a name="l4488"><span class="ln">4488 </span></a>            <span class="s1">self.expr.streamline()</span>
4509 <a name="l4489"><span class="ln">4489 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4510 <a name="l4490"><span class="ln">4490 </span></a>
4511 <a name="l4491"><span class="ln">4491 </span></a>    <span class="s3">def </span><span class="s1">checkRecursion(self</span><span class="s3">, </span><span class="s1">parseElementList):</span>
4512 <a name="l4492"><span class="ln">4492 </span></a>        <span class="s3">if </span><span class="s1">self </span><span class="s3">in </span><span class="s1">parseElementList:</span>
4513 <a name="l4493"><span class="ln">4493 </span></a>            <span class="s3">raise </span><span class="s1">RecursiveGrammarException(parseElementList + [self])</span>
4514 <a name="l4494"><span class="ln">4494 </span></a>        <span class="s1">subRecCheckList = parseElementList[:] + [self]</span>
4515 <a name="l4495"><span class="ln">4495 </span></a>        <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4516 <a name="l4496"><span class="ln">4496 </span></a>            <span class="s1">self.expr.checkRecursion(subRecCheckList)</span>
4517 <a name="l4497"><span class="ln">4497 </span></a>
4518 <a name="l4498"><span class="ln">4498 </span></a>    <span class="s3">def </span><span class="s1">validate(self</span><span class="s3">, </span><span class="s1">validateTrace=</span><span class="s3">None</span><span class="s1">):</span>
4519 <a name="l4499"><span class="ln">4499 </span></a>        <span class="s3">if </span><span class="s1">validateTrace </span><span class="s3">is None</span><span class="s1">:</span>
4520 <a name="l4500"><span class="ln">4500 </span></a>            <span class="s1">validateTrace = []</span>
4521 <a name="l4501"><span class="ln">4501 </span></a>        <span class="s1">tmp = validateTrace[:] + [self]</span>
4522 <a name="l4502"><span class="ln">4502 </span></a>        <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4523 <a name="l4503"><span class="ln">4503 </span></a>            <span class="s1">self.expr.validate(tmp)</span>
4524 <a name="l4504"><span class="ln">4504 </span></a>        <span class="s1">self.checkRecursion([])</span>
4525 <a name="l4505"><span class="ln">4505 </span></a>
4526 <a name="l4506"><span class="ln">4506 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4527 <a name="l4507"><span class="ln">4507 </span></a>        <span class="s3">try</span><span class="s1">:</span>
4528 <a name="l4508"><span class="ln">4508 </span></a>            <span class="s3">return </span><span class="s1">super(ParseElementEnhance</span><span class="s3">, </span><span class="s1">self).__str__()</span>
4529 <a name="l4509"><span class="ln">4509 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
4530 <a name="l4510"><span class="ln">4510 </span></a>            <span class="s3">pass</span>
4531 <a name="l4511"><span class="ln">4511 </span></a>
4532 <a name="l4512"><span class="ln">4512 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None and </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
4533 <a name="l4513"><span class="ln">4513 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;%s:(%s)&quot; </span><span class="s1">% (self.__class__.__name__</span><span class="s3">, </span><span class="s1">_ustr(self.expr))</span>
4534 <a name="l4514"><span class="ln">4514 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4535 <a name="l4515"><span class="ln">4515 </span></a>
4536 <a name="l4516"><span class="ln">4516 </span></a>
4537 <a name="l4517"><span class="ln">4517 </span></a><span class="s3">class </span><span class="s1">FollowedBy(ParseElementEnhance):</span>
4538 <a name="l4518"><span class="ln">4518 </span></a>    <span class="s5">&quot;&quot;&quot;Lookahead matching of the given parse expression. 
4539 <a name="l4519"><span class="ln">4519 </span></a>    ``FollowedBy`` does *not* advance the parsing position within 
4540 <a name="l4520"><span class="ln">4520 </span></a>    the input string, it only verifies that the specified parse 
4541 <a name="l4521"><span class="ln">4521 </span></a>    expression matches at the current position.  ``FollowedBy`` 
4542 <a name="l4522"><span class="ln">4522 </span></a>    always returns a null token list. If any results names are defined 
4543 <a name="l4523"><span class="ln">4523 </span></a>    in the lookahead expression, those *will* be returned for access by 
4544 <a name="l4524"><span class="ln">4524 </span></a>    name. 
4545 <a name="l4525"><span class="ln">4525 </span></a> 
4546 <a name="l4526"><span class="ln">4526 </span></a>    Example:: 
4547 <a name="l4527"><span class="ln">4527 </span></a> 
4548 <a name="l4528"><span class="ln">4528 </span></a>        # use FollowedBy to match a label only if it is followed by a ':' 
4549 <a name="l4529"><span class="ln">4529 </span></a>        data_word = Word(alphas) 
4550 <a name="l4530"><span class="ln">4530 </span></a>        label = data_word + FollowedBy(':') 
4551 <a name="l4531"><span class="ln">4531 </span></a>        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
4552 <a name="l4532"><span class="ln">4532 </span></a> 
4553 <a name="l4533"><span class="ln">4533 </span></a>        OneOrMore(attr_expr).parseString(&quot;shape: SQUARE color: BLACK posn: upper left&quot;).pprint() 
4554 <a name="l4534"><span class="ln">4534 </span></a> 
4555 <a name="l4535"><span class="ln">4535 </span></a>    prints:: 
4556 <a name="l4536"><span class="ln">4536 </span></a> 
4557 <a name="l4537"><span class="ln">4537 </span></a>        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']] 
4558 <a name="l4538"><span class="ln">4538 </span></a>    &quot;&quot;&quot;</span>
4559 <a name="l4539"><span class="ln">4539 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr):</span>
4560 <a name="l4540"><span class="ln">4540 </span></a>        <span class="s1">super(FollowedBy</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
4561 <a name="l4541"><span class="ln">4541 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4562 <a name="l4542"><span class="ln">4542 </span></a>
4563 <a name="l4543"><span class="ln">4543 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4564 <a name="l4544"><span class="ln">4544 </span></a>        <span class="s0"># by using self._expr.parse and deleting the contents of the returned ParseResults list</span>
4565 <a name="l4545"><span class="ln">4545 </span></a>        <span class="s0"># we keep any named results that were defined in the FollowedBy expression</span>
4566 <a name="l4546"><span class="ln">4546 </span></a>        <span class="s1">_</span><span class="s3">, </span><span class="s1">ret = self.expr._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=doActions)</span>
4567 <a name="l4547"><span class="ln">4547 </span></a>        <span class="s3">del </span><span class="s1">ret[:]</span>
4568 <a name="l4548"><span class="ln">4548 </span></a>
4569 <a name="l4549"><span class="ln">4549 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">ret</span>
4570 <a name="l4550"><span class="ln">4550 </span></a>
4571 <a name="l4551"><span class="ln">4551 </span></a>
4572 <a name="l4552"><span class="ln">4552 </span></a><span class="s3">class </span><span class="s1">PrecededBy(ParseElementEnhance):</span>
4573 <a name="l4553"><span class="ln">4553 </span></a>    <span class="s5">&quot;&quot;&quot;Lookbehind matching of the given parse expression. 
4574 <a name="l4554"><span class="ln">4554 </span></a>    ``PrecededBy`` does not advance the parsing position within the 
4575 <a name="l4555"><span class="ln">4555 </span></a>    input string, it only verifies that the specified parse expression 
4576 <a name="l4556"><span class="ln">4556 </span></a>    matches prior to the current position.  ``PrecededBy`` always 
4577 <a name="l4557"><span class="ln">4557 </span></a>    returns a null token list, but if a results name is defined on the 
4578 <a name="l4558"><span class="ln">4558 </span></a>    given expression, it is returned. 
4579 <a name="l4559"><span class="ln">4559 </span></a> 
4580 <a name="l4560"><span class="ln">4560 </span></a>    Parameters: 
4581 <a name="l4561"><span class="ln">4561 </span></a> 
4582 <a name="l4562"><span class="ln">4562 </span></a>     - expr - expression that must match prior to the current parse 
4583 <a name="l4563"><span class="ln">4563 </span></a>       location 
4584 <a name="l4564"><span class="ln">4564 </span></a>     - retreat - (default= ``None``) - (int) maximum number of characters 
4585 <a name="l4565"><span class="ln">4565 </span></a>       to lookbehind prior to the current parse location 
4586 <a name="l4566"><span class="ln">4566 </span></a> 
4587 <a name="l4567"><span class="ln">4567 </span></a>    If the lookbehind expression is a string, Literal, Keyword, or 
4588 <a name="l4568"><span class="ln">4568 </span></a>    a Word or CharsNotIn with a specified exact or maximum length, then 
4589 <a name="l4569"><span class="ln">4569 </span></a>    the retreat parameter is not required. Otherwise, retreat must be 
4590 <a name="l4570"><span class="ln">4570 </span></a>    specified to give a maximum number of characters to look back from 
4591 <a name="l4571"><span class="ln">4571 </span></a>    the current parse position for a lookbehind match. 
4592 <a name="l4572"><span class="ln">4572 </span></a> 
4593 <a name="l4573"><span class="ln">4573 </span></a>    Example:: 
4594 <a name="l4574"><span class="ln">4574 </span></a> 
4595 <a name="l4575"><span class="ln">4575 </span></a>        # VB-style variable names with type prefixes 
4596 <a name="l4576"><span class="ln">4576 </span></a>        int_var = PrecededBy(&quot;#&quot;) + pyparsing_common.identifier 
4597 <a name="l4577"><span class="ln">4577 </span></a>        str_var = PrecededBy(&quot;$&quot;) + pyparsing_common.identifier 
4598 <a name="l4578"><span class="ln">4578 </span></a> 
4599 <a name="l4579"><span class="ln">4579 </span></a>    &quot;&quot;&quot;</span>
4600 <a name="l4580"><span class="ln">4580 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">retreat=</span><span class="s3">None</span><span class="s1">):</span>
4601 <a name="l4581"><span class="ln">4581 </span></a>        <span class="s1">super(PrecededBy</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
4602 <a name="l4582"><span class="ln">4582 </span></a>        <span class="s1">self.expr = self.expr().leaveWhitespace()</span>
4603 <a name="l4583"><span class="ln">4583 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4604 <a name="l4584"><span class="ln">4584 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
4605 <a name="l4585"><span class="ln">4585 </span></a>        <span class="s1">self.exact = </span><span class="s3">False</span>
4606 <a name="l4586"><span class="ln">4586 </span></a>        <span class="s3">if </span><span class="s1">isinstance(expr</span><span class="s3">, </span><span class="s1">str):</span>
4607 <a name="l4587"><span class="ln">4587 </span></a>            <span class="s1">retreat = len(expr)</span>
4608 <a name="l4588"><span class="ln">4588 </span></a>            <span class="s1">self.exact = </span><span class="s3">True</span>
4609 <a name="l4589"><span class="ln">4589 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(expr</span><span class="s3">, </span><span class="s1">(Literal</span><span class="s3">, </span><span class="s1">Keyword)):</span>
4610 <a name="l4590"><span class="ln">4590 </span></a>            <span class="s1">retreat = expr.matchLen</span>
4611 <a name="l4591"><span class="ln">4591 </span></a>            <span class="s1">self.exact = </span><span class="s3">True</span>
4612 <a name="l4592"><span class="ln">4592 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(expr</span><span class="s3">, </span><span class="s1">(Word</span><span class="s3">, </span><span class="s1">CharsNotIn)) </span><span class="s3">and </span><span class="s1">expr.maxLen != _MAX_INT:</span>
4613 <a name="l4593"><span class="ln">4593 </span></a>            <span class="s1">retreat = expr.maxLen</span>
4614 <a name="l4594"><span class="ln">4594 </span></a>            <span class="s1">self.exact = </span><span class="s3">True</span>
4615 <a name="l4595"><span class="ln">4595 </span></a>        <span class="s3">elif </span><span class="s1">isinstance(expr</span><span class="s3">, </span><span class="s1">_PositionToken):</span>
4616 <a name="l4596"><span class="ln">4596 </span></a>            <span class="s1">retreat = </span><span class="s4">0</span>
4617 <a name="l4597"><span class="ln">4597 </span></a>            <span class="s1">self.exact = </span><span class="s3">True</span>
4618 <a name="l4598"><span class="ln">4598 </span></a>        <span class="s1">self.retreat = retreat</span>
4619 <a name="l4599"><span class="ln">4599 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;not preceded by &quot; </span><span class="s1">+ str(expr)</span>
4620 <a name="l4600"><span class="ln">4600 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
4621 <a name="l4601"><span class="ln">4601 </span></a>        <span class="s1">self.parseAction.append(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: t.__delitem__(slice(</span><span class="s3">None, None</span><span class="s1">)))</span>
4622 <a name="l4602"><span class="ln">4602 </span></a>
4623 <a name="l4603"><span class="ln">4603 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc=</span><span class="s4">0</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4624 <a name="l4604"><span class="ln">4604 </span></a>        <span class="s3">if </span><span class="s1">self.exact:</span>
4625 <a name="l4605"><span class="ln">4605 </span></a>            <span class="s3">if </span><span class="s1">loc &lt; self.retreat:</span>
4626 <a name="l4606"><span class="ln">4606 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg)</span>
4627 <a name="l4607"><span class="ln">4607 </span></a>            <span class="s1">start = loc - self.retreat</span>
4628 <a name="l4608"><span class="ln">4608 </span></a>            <span class="s1">_</span><span class="s3">, </span><span class="s1">ret = self.expr._parse(instring</span><span class="s3">, </span><span class="s1">start)</span>
4629 <a name="l4609"><span class="ln">4609 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4630 <a name="l4610"><span class="ln">4610 </span></a>            <span class="s0"># retreat specified a maximum lookbehind window, iterate</span>
4631 <a name="l4611"><span class="ln">4611 </span></a>            <span class="s1">test_expr = self.expr + StringEnd()</span>
4632 <a name="l4612"><span class="ln">4612 </span></a>            <span class="s1">instring_slice = instring[max(</span><span class="s4">0</span><span class="s3">, </span><span class="s1">loc - self.retreat):loc]</span>
4633 <a name="l4613"><span class="ln">4613 </span></a>            <span class="s1">last_expr = ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg)</span>
4634 <a name="l4614"><span class="ln">4614 </span></a>            <span class="s3">for </span><span class="s1">offset </span><span class="s3">in </span><span class="s1">range(</span><span class="s4">1</span><span class="s3">, </span><span class="s1">min(loc</span><span class="s3">, </span><span class="s1">self.retreat + </span><span class="s4">1</span><span class="s1">)+</span><span class="s4">1</span><span class="s1">):</span>
4635 <a name="l4615"><span class="ln">4615 </span></a>                <span class="s3">try</span><span class="s1">:</span>
4636 <a name="l4616"><span class="ln">4616 </span></a>                    <span class="s0"># print('trying', offset, instring_slice, repr(instring_slice[loc - offset:]))</span>
4637 <a name="l4617"><span class="ln">4617 </span></a>                    <span class="s1">_</span><span class="s3">, </span><span class="s1">ret = test_expr._parse(instring_slice</span><span class="s3">, </span><span class="s1">len(instring_slice) - offset)</span>
4638 <a name="l4618"><span class="ln">4618 </span></a>                <span class="s3">except </span><span class="s1">ParseBaseException </span><span class="s3">as </span><span class="s1">pbe:</span>
4639 <a name="l4619"><span class="ln">4619 </span></a>                    <span class="s1">last_expr = pbe</span>
4640 <a name="l4620"><span class="ln">4620 </span></a>                <span class="s3">else</span><span class="s1">:</span>
4641 <a name="l4621"><span class="ln">4621 </span></a>                    <span class="s3">break</span>
4642 <a name="l4622"><span class="ln">4622 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4643 <a name="l4623"><span class="ln">4623 </span></a>                <span class="s3">raise </span><span class="s1">last_expr</span>
4644 <a name="l4624"><span class="ln">4624 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">ret</span>
4645 <a name="l4625"><span class="ln">4625 </span></a>
4646 <a name="l4626"><span class="ln">4626 </span></a>
4647 <a name="l4627"><span class="ln">4627 </span></a><span class="s3">class </span><span class="s1">NotAny(ParseElementEnhance):</span>
4648 <a name="l4628"><span class="ln">4628 </span></a>    <span class="s5">&quot;&quot;&quot;Lookahead to disallow matching with the given parse expression. 
4649 <a name="l4629"><span class="ln">4629 </span></a>    ``NotAny`` does *not* advance the parsing position within the 
4650 <a name="l4630"><span class="ln">4630 </span></a>    input string, it only verifies that the specified parse expression 
4651 <a name="l4631"><span class="ln">4631 </span></a>    does *not* match at the current position.  Also, ``NotAny`` does 
4652 <a name="l4632"><span class="ln">4632 </span></a>    *not* skip over leading whitespace. ``NotAny`` always returns 
4653 <a name="l4633"><span class="ln">4633 </span></a>    a null token list.  May be constructed using the '~' operator. 
4654 <a name="l4634"><span class="ln">4634 </span></a> 
4655 <a name="l4635"><span class="ln">4635 </span></a>    Example:: 
4656 <a name="l4636"><span class="ln">4636 </span></a> 
4657 <a name="l4637"><span class="ln">4637 </span></a>        AND, OR, NOT = map(CaselessKeyword, &quot;AND OR NOT&quot;.split()) 
4658 <a name="l4638"><span class="ln">4638 </span></a> 
4659 <a name="l4639"><span class="ln">4639 </span></a>        # take care not to mistake keywords for identifiers 
4660 <a name="l4640"><span class="ln">4640 </span></a>        ident = ~(AND | OR | NOT) + Word(alphas) 
4661 <a name="l4641"><span class="ln">4641 </span></a>        boolean_term = Optional(NOT) + ident 
4662 <a name="l4642"><span class="ln">4642 </span></a> 
4663 <a name="l4643"><span class="ln">4643 </span></a>        # very crude boolean expression - to support parenthesis groups and 
4664 <a name="l4644"><span class="ln">4644 </span></a>        # operation hierarchy, use infixNotation 
4665 <a name="l4645"><span class="ln">4645 </span></a>        boolean_expr = boolean_term + ZeroOrMore((AND | OR) + boolean_term) 
4666 <a name="l4646"><span class="ln">4646 </span></a> 
4667 <a name="l4647"><span class="ln">4647 </span></a>        # integers that are followed by &quot;.&quot; are actually floats 
4668 <a name="l4648"><span class="ln">4648 </span></a>        integer = Word(nums) + ~Char(&quot;.&quot;) 
4669 <a name="l4649"><span class="ln">4649 </span></a>    &quot;&quot;&quot;</span>
4670 <a name="l4650"><span class="ln">4650 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr):</span>
4671 <a name="l4651"><span class="ln">4651 </span></a>        <span class="s1">super(NotAny</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
4672 <a name="l4652"><span class="ln">4652 </span></a>        <span class="s0"># ~ self.leaveWhitespace()</span>
4673 <a name="l4653"><span class="ln">4653 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False  </span><span class="s0"># do NOT use self.leaveWhitespace(), don't want to propagate to exprs</span>
4674 <a name="l4654"><span class="ln">4654 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4675 <a name="l4655"><span class="ln">4655 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;Found unwanted token, &quot; </span><span class="s1">+ _ustr(self.expr)</span>
4676 <a name="l4656"><span class="ln">4656 </span></a>
4677 <a name="l4657"><span class="ln">4657 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4678 <a name="l4658"><span class="ln">4658 </span></a>        <span class="s3">if </span><span class="s1">self.expr.canParseNext(instring</span><span class="s3">, </span><span class="s1">loc):</span>
4679 <a name="l4659"><span class="ln">4659 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
4680 <a name="l4660"><span class="ln">4660 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
4681 <a name="l4661"><span class="ln">4661 </span></a>
4682 <a name="l4662"><span class="ln">4662 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4683 <a name="l4663"><span class="ln">4663 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4684 <a name="l4664"><span class="ln">4664 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4685 <a name="l4665"><span class="ln">4665 </span></a>
4686 <a name="l4666"><span class="ln">4666 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4687 <a name="l4667"><span class="ln">4667 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;~{&quot; </span><span class="s1">+ _ustr(self.expr) + </span><span class="s2">&quot;}&quot;</span>
4688 <a name="l4668"><span class="ln">4668 </span></a>
4689 <a name="l4669"><span class="ln">4669 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4690 <a name="l4670"><span class="ln">4670 </span></a>
4691 <a name="l4671"><span class="ln">4671 </span></a><span class="s3">class </span><span class="s1">_MultipleMatch(ParseElementEnhance):</span>
4692 <a name="l4672"><span class="ln">4672 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">stopOn=</span><span class="s3">None</span><span class="s1">):</span>
4693 <a name="l4673"><span class="ln">4673 </span></a>        <span class="s1">super(_MultipleMatch</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
4694 <a name="l4674"><span class="ln">4674 </span></a>        <span class="s1">self.saveAsList = </span><span class="s3">True</span>
4695 <a name="l4675"><span class="ln">4675 </span></a>        <span class="s1">ender = stopOn</span>
4696 <a name="l4676"><span class="ln">4676 </span></a>        <span class="s3">if </span><span class="s1">isinstance(ender</span><span class="s3">, </span><span class="s1">basestring):</span>
4697 <a name="l4677"><span class="ln">4677 </span></a>            <span class="s1">ender = self._literalStringClass(ender)</span>
4698 <a name="l4678"><span class="ln">4678 </span></a>        <span class="s1">self.stopOn(ender)</span>
4699 <a name="l4679"><span class="ln">4679 </span></a>
4700 <a name="l4680"><span class="ln">4680 </span></a>    <span class="s3">def </span><span class="s1">stopOn(self</span><span class="s3">, </span><span class="s1">ender):</span>
4701 <a name="l4681"><span class="ln">4681 </span></a>        <span class="s3">if </span><span class="s1">isinstance(ender</span><span class="s3">, </span><span class="s1">basestring):</span>
4702 <a name="l4682"><span class="ln">4682 </span></a>            <span class="s1">ender = self._literalStringClass(ender)</span>
4703 <a name="l4683"><span class="ln">4683 </span></a>        <span class="s1">self.not_ender = ~ender </span><span class="s3">if </span><span class="s1">ender </span><span class="s3">is not None else None</span>
4704 <a name="l4684"><span class="ln">4684 </span></a>        <span class="s3">return </span><span class="s1">self</span>
4705 <a name="l4685"><span class="ln">4685 </span></a>
4706 <a name="l4686"><span class="ln">4686 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4707 <a name="l4687"><span class="ln">4687 </span></a>        <span class="s1">self_expr_parse = self.expr._parse</span>
4708 <a name="l4688"><span class="ln">4688 </span></a>        <span class="s1">self_skip_ignorables = self._skipIgnorables</span>
4709 <a name="l4689"><span class="ln">4689 </span></a>        <span class="s1">check_ender = self.not_ender </span><span class="s3">is not None</span>
4710 <a name="l4690"><span class="ln">4690 </span></a>        <span class="s3">if </span><span class="s1">check_ender:</span>
4711 <a name="l4691"><span class="ln">4691 </span></a>            <span class="s1">try_not_ender = self.not_ender.tryParse</span>
4712 <a name="l4692"><span class="ln">4692 </span></a>
4713 <a name="l4693"><span class="ln">4693 </span></a>        <span class="s0"># must be at least one (but first see if we are the stopOn sentinel;</span>
4714 <a name="l4694"><span class="ln">4694 </span></a>        <span class="s0"># if so, fail)</span>
4715 <a name="l4695"><span class="ln">4695 </span></a>        <span class="s3">if </span><span class="s1">check_ender:</span>
4716 <a name="l4696"><span class="ln">4696 </span></a>            <span class="s1">try_not_ender(instring</span><span class="s3">, </span><span class="s1">loc)</span>
4717 <a name="l4697"><span class="ln">4697 </span></a>        <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self_expr_parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
4718 <a name="l4698"><span class="ln">4698 </span></a>        <span class="s3">try</span><span class="s1">:</span>
4719 <a name="l4699"><span class="ln">4699 </span></a>            <span class="s1">hasIgnoreExprs = (</span><span class="s3">not not </span><span class="s1">self.ignoreExprs)</span>
4720 <a name="l4700"><span class="ln">4700 </span></a>            <span class="s3">while </span><span class="s4">1</span><span class="s1">:</span>
4721 <a name="l4701"><span class="ln">4701 </span></a>                <span class="s3">if </span><span class="s1">check_ender:</span>
4722 <a name="l4702"><span class="ln">4702 </span></a>                    <span class="s1">try_not_ender(instring</span><span class="s3">, </span><span class="s1">loc)</span>
4723 <a name="l4703"><span class="ln">4703 </span></a>                <span class="s3">if </span><span class="s1">hasIgnoreExprs:</span>
4724 <a name="l4704"><span class="ln">4704 </span></a>                    <span class="s1">preloc = self_skip_ignorables(instring</span><span class="s3">, </span><span class="s1">loc)</span>
4725 <a name="l4705"><span class="ln">4705 </span></a>                <span class="s3">else</span><span class="s1">:</span>
4726 <a name="l4706"><span class="ln">4706 </span></a>                    <span class="s1">preloc = loc</span>
4727 <a name="l4707"><span class="ln">4707 </span></a>                <span class="s1">loc</span><span class="s3">, </span><span class="s1">tmptokens = self_expr_parse(instring</span><span class="s3">, </span><span class="s1">preloc</span><span class="s3">, </span><span class="s1">doActions)</span>
4728 <a name="l4708"><span class="ln">4708 </span></a>                <span class="s3">if </span><span class="s1">tmptokens </span><span class="s3">or </span><span class="s1">tmptokens.haskeys():</span>
4729 <a name="l4709"><span class="ln">4709 </span></a>                    <span class="s1">tokens += tmptokens</span>
4730 <a name="l4710"><span class="ln">4710 </span></a>        <span class="s3">except </span><span class="s1">(ParseException</span><span class="s3">, </span><span class="s1">IndexError):</span>
4731 <a name="l4711"><span class="ln">4711 </span></a>            <span class="s3">pass</span>
4732 <a name="l4712"><span class="ln">4712 </span></a>
4733 <a name="l4713"><span class="ln">4713 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens</span>
4734 <a name="l4714"><span class="ln">4714 </span></a>
4735 <a name="l4715"><span class="ln">4715 </span></a>    <span class="s3">def </span><span class="s1">_setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
4736 <a name="l4716"><span class="ln">4716 </span></a>        <span class="s3">if </span><span class="s1">__diag__.warn_ungrouped_named_tokens_in_collection:</span>
4737 <a name="l4717"><span class="ln">4717 </span></a>            <span class="s3">for </span><span class="s1">e </span><span class="s3">in </span><span class="s1">[self.expr] + getattr(self.expr</span><span class="s3">, </span><span class="s2">'exprs'</span><span class="s3">, </span><span class="s1">[]):</span>
4738 <a name="l4718"><span class="ln">4718 </span></a>                <span class="s3">if </span><span class="s1">isinstance(e</span><span class="s3">, </span><span class="s1">ParserElement) </span><span class="s3">and </span><span class="s1">e.resultsName:</span>
4739 <a name="l4719"><span class="ln">4719 </span></a>                    <span class="s1">warnings.warn(</span><span class="s2">&quot;{0}: setting results name {1!r} on {2} expression &quot;</span>
4740 <a name="l4720"><span class="ln">4720 </span></a>                                  <span class="s2">&quot;collides with {3!r} on contained expression&quot;</span><span class="s1">.format(</span><span class="s2">&quot;warn_ungrouped_named_tokens_in_collection&quot;</span><span class="s3">,</span>
4741 <a name="l4721"><span class="ln">4721 </span></a>                                                                                       <span class="s1">name</span><span class="s3">,</span>
4742 <a name="l4722"><span class="ln">4722 </span></a>                                                                                       <span class="s1">type(self).__name__</span><span class="s3">,</span>
4743 <a name="l4723"><span class="ln">4723 </span></a>                                                                                       <span class="s1">e.resultsName)</span><span class="s3">,</span>
4744 <a name="l4724"><span class="ln">4724 </span></a>                                  <span class="s1">stacklevel=</span><span class="s4">3</span><span class="s1">)</span>
4745 <a name="l4725"><span class="ln">4725 </span></a>
4746 <a name="l4726"><span class="ln">4726 </span></a>        <span class="s3">return </span><span class="s1">super(_MultipleMatch</span><span class="s3">, </span><span class="s1">self)._setResultsName(name</span><span class="s3">, </span><span class="s1">listAllMatches)</span>
4747 <a name="l4727"><span class="ln">4727 </span></a>
4748 <a name="l4728"><span class="ln">4728 </span></a>
4749 <a name="l4729"><span class="ln">4729 </span></a><span class="s3">class </span><span class="s1">OneOrMore(_MultipleMatch):</span>
4750 <a name="l4730"><span class="ln">4730 </span></a>    <span class="s5">&quot;&quot;&quot;Repetition of one or more of the given expression. 
4751 <a name="l4731"><span class="ln">4731 </span></a> 
4752 <a name="l4732"><span class="ln">4732 </span></a>    Parameters: 
4753 <a name="l4733"><span class="ln">4733 </span></a>     - expr - expression that must match one or more times 
4754 <a name="l4734"><span class="ln">4734 </span></a>     - stopOn - (default= ``None``) - expression for a terminating sentinel 
4755 <a name="l4735"><span class="ln">4735 </span></a>          (only required if the sentinel would ordinarily match the repetition 
4756 <a name="l4736"><span class="ln">4736 </span></a>          expression) 
4757 <a name="l4737"><span class="ln">4737 </span></a> 
4758 <a name="l4738"><span class="ln">4738 </span></a>    Example:: 
4759 <a name="l4739"><span class="ln">4739 </span></a> 
4760 <a name="l4740"><span class="ln">4740 </span></a>        data_word = Word(alphas) 
4761 <a name="l4741"><span class="ln">4741 </span></a>        label = data_word + FollowedBy(':') 
4762 <a name="l4742"><span class="ln">4742 </span></a>        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) 
4763 <a name="l4743"><span class="ln">4743 </span></a> 
4764 <a name="l4744"><span class="ln">4744 </span></a>        text = &quot;shape: SQUARE posn: upper left color: BLACK&quot; 
4765 <a name="l4745"><span class="ln">4745 </span></a>        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -&gt; [['shape', 'SQUARE color']] 
4766 <a name="l4746"><span class="ln">4746 </span></a> 
4767 <a name="l4747"><span class="ln">4747 </span></a>        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data 
4768 <a name="l4748"><span class="ln">4748 </span></a>        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
4769 <a name="l4749"><span class="ln">4749 </span></a>        OneOrMore(attr_expr).parseString(text).pprint() # Better -&gt; [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']] 
4770 <a name="l4750"><span class="ln">4750 </span></a> 
4771 <a name="l4751"><span class="ln">4751 </span></a>        # could also be written as 
4772 <a name="l4752"><span class="ln">4752 </span></a>        (attr_expr * (1,)).parseString(text).pprint() 
4773 <a name="l4753"><span class="ln">4753 </span></a>    &quot;&quot;&quot;</span>
4774 <a name="l4754"><span class="ln">4754 </span></a>
4775 <a name="l4755"><span class="ln">4755 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4776 <a name="l4756"><span class="ln">4756 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4777 <a name="l4757"><span class="ln">4757 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4778 <a name="l4758"><span class="ln">4758 </span></a>
4779 <a name="l4759"><span class="ln">4759 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4780 <a name="l4760"><span class="ln">4760 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;{&quot; </span><span class="s1">+ _ustr(self.expr) + </span><span class="s2">&quot;}...&quot;</span>
4781 <a name="l4761"><span class="ln">4761 </span></a>
4782 <a name="l4762"><span class="ln">4762 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4783 <a name="l4763"><span class="ln">4763 </span></a>
4784 <a name="l4764"><span class="ln">4764 </span></a><span class="s3">class </span><span class="s1">ZeroOrMore(_MultipleMatch):</span>
4785 <a name="l4765"><span class="ln">4765 </span></a>    <span class="s5">&quot;&quot;&quot;Optional repetition of zero or more of the given expression. 
4786 <a name="l4766"><span class="ln">4766 </span></a> 
4787 <a name="l4767"><span class="ln">4767 </span></a>    Parameters: 
4788 <a name="l4768"><span class="ln">4768 </span></a>     - expr - expression that must match zero or more times 
4789 <a name="l4769"><span class="ln">4769 </span></a>     - stopOn - (default= ``None``) - expression for a terminating sentinel 
4790 <a name="l4770"><span class="ln">4770 </span></a>          (only required if the sentinel would ordinarily match the repetition 
4791 <a name="l4771"><span class="ln">4771 </span></a>          expression) 
4792 <a name="l4772"><span class="ln">4772 </span></a> 
4793 <a name="l4773"><span class="ln">4773 </span></a>    Example: similar to :class:`OneOrMore` 
4794 <a name="l4774"><span class="ln">4774 </span></a>    &quot;&quot;&quot;</span>
4795 <a name="l4775"><span class="ln">4775 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">stopOn=</span><span class="s3">None</span><span class="s1">):</span>
4796 <a name="l4776"><span class="ln">4776 </span></a>        <span class="s1">super(ZeroOrMore</span><span class="s3">, </span><span class="s1">self).__init__(expr</span><span class="s3">, </span><span class="s1">stopOn=stopOn)</span>
4797 <a name="l4777"><span class="ln">4777 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4798 <a name="l4778"><span class="ln">4778 </span></a>
4799 <a name="l4779"><span class="ln">4779 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4800 <a name="l4780"><span class="ln">4780 </span></a>        <span class="s3">try</span><span class="s1">:</span>
4801 <a name="l4781"><span class="ln">4781 </span></a>            <span class="s3">return </span><span class="s1">super(ZeroOrMore</span><span class="s3">, </span><span class="s1">self).parseImpl(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions)</span>
4802 <a name="l4782"><span class="ln">4782 </span></a>        <span class="s3">except </span><span class="s1">(ParseException</span><span class="s3">, </span><span class="s1">IndexError):</span>
4803 <a name="l4783"><span class="ln">4783 </span></a>            <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
4804 <a name="l4784"><span class="ln">4784 </span></a>
4805 <a name="l4785"><span class="ln">4785 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4806 <a name="l4786"><span class="ln">4786 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4807 <a name="l4787"><span class="ln">4787 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4808 <a name="l4788"><span class="ln">4788 </span></a>
4809 <a name="l4789"><span class="ln">4789 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4810 <a name="l4790"><span class="ln">4790 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;[&quot; </span><span class="s1">+ _ustr(self.expr) + </span><span class="s2">&quot;]...&quot;</span>
4811 <a name="l4791"><span class="ln">4791 </span></a>
4812 <a name="l4792"><span class="ln">4792 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4813 <a name="l4793"><span class="ln">4793 </span></a>
4814 <a name="l4794"><span class="ln">4794 </span></a>
4815 <a name="l4795"><span class="ln">4795 </span></a><span class="s3">class </span><span class="s1">_NullToken(object):</span>
4816 <a name="l4796"><span class="ln">4796 </span></a>    <span class="s3">def </span><span class="s1">__bool__(self):</span>
4817 <a name="l4797"><span class="ln">4797 </span></a>        <span class="s3">return False</span>
4818 <a name="l4798"><span class="ln">4798 </span></a>    <span class="s1">__nonzero__ = __bool__</span>
4819 <a name="l4799"><span class="ln">4799 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4820 <a name="l4800"><span class="ln">4800 </span></a>        <span class="s3">return </span><span class="s2">&quot;&quot;</span>
4821 <a name="l4801"><span class="ln">4801 </span></a>
4822 <a name="l4802"><span class="ln">4802 </span></a><span class="s3">class </span><span class="s1">Optional(ParseElementEnhance):</span>
4823 <a name="l4803"><span class="ln">4803 </span></a>    <span class="s5">&quot;&quot;&quot;Optional matching of the given expression. 
4824 <a name="l4804"><span class="ln">4804 </span></a> 
4825 <a name="l4805"><span class="ln">4805 </span></a>    Parameters: 
4826 <a name="l4806"><span class="ln">4806 </span></a>     - expr - expression that must match zero or more times 
4827 <a name="l4807"><span class="ln">4807 </span></a>     - default (optional) - value to be returned if the optional expression is not found. 
4828 <a name="l4808"><span class="ln">4808 </span></a> 
4829 <a name="l4809"><span class="ln">4809 </span></a>    Example:: 
4830 <a name="l4810"><span class="ln">4810 </span></a> 
4831 <a name="l4811"><span class="ln">4811 </span></a>        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier 
4832 <a name="l4812"><span class="ln">4812 </span></a>        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4))) 
4833 <a name="l4813"><span class="ln">4813 </span></a>        zip.runTests(''' 
4834 <a name="l4814"><span class="ln">4814 </span></a>            # traditional ZIP code 
4835 <a name="l4815"><span class="ln">4815 </span></a>            12345 
4836 <a name="l4816"><span class="ln">4816 </span></a> 
4837 <a name="l4817"><span class="ln">4817 </span></a>            # ZIP+4 form 
4838 <a name="l4818"><span class="ln">4818 </span></a>            12101-0001 
4839 <a name="l4819"><span class="ln">4819 </span></a> 
4840 <a name="l4820"><span class="ln">4820 </span></a>            # invalid ZIP 
4841 <a name="l4821"><span class="ln">4821 </span></a>            98765- 
4842 <a name="l4822"><span class="ln">4822 </span></a>            ''') 
4843 <a name="l4823"><span class="ln">4823 </span></a> 
4844 <a name="l4824"><span class="ln">4824 </span></a>    prints:: 
4845 <a name="l4825"><span class="ln">4825 </span></a> 
4846 <a name="l4826"><span class="ln">4826 </span></a>        # traditional ZIP code 
4847 <a name="l4827"><span class="ln">4827 </span></a>        12345 
4848 <a name="l4828"><span class="ln">4828 </span></a>        ['12345'] 
4849 <a name="l4829"><span class="ln">4829 </span></a> 
4850 <a name="l4830"><span class="ln">4830 </span></a>        # ZIP+4 form 
4851 <a name="l4831"><span class="ln">4831 </span></a>        12101-0001 
4852 <a name="l4832"><span class="ln">4832 </span></a>        ['12101-0001'] 
4853 <a name="l4833"><span class="ln">4833 </span></a> 
4854 <a name="l4834"><span class="ln">4834 </span></a>        # invalid ZIP 
4855 <a name="l4835"><span class="ln">4835 </span></a>        98765- 
4856 <a name="l4836"><span class="ln">4836 </span></a>             ^ 
4857 <a name="l4837"><span class="ln">4837 </span></a>        FAIL: Expected end of text (at char 5), (line:1, col:6) 
4858 <a name="l4838"><span class="ln">4838 </span></a>    &quot;&quot;&quot;</span>
4859 <a name="l4839"><span class="ln">4839 </span></a>    <span class="s1">__optionalNotMatched = _NullToken()</span>
4860 <a name="l4840"><span class="ln">4840 </span></a>
4861 <a name="l4841"><span class="ln">4841 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">default=__optionalNotMatched):</span>
4862 <a name="l4842"><span class="ln">4842 </span></a>        <span class="s1">super(Optional</span><span class="s3">, </span><span class="s1">self).__init__(expr</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">)</span>
4863 <a name="l4843"><span class="ln">4843 </span></a>        <span class="s1">self.saveAsList = self.expr.saveAsList</span>
4864 <a name="l4844"><span class="ln">4844 </span></a>        <span class="s1">self.defaultValue = default</span>
4865 <a name="l4845"><span class="ln">4845 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4866 <a name="l4846"><span class="ln">4846 </span></a>
4867 <a name="l4847"><span class="ln">4847 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4868 <a name="l4848"><span class="ln">4848 </span></a>        <span class="s3">try</span><span class="s1">:</span>
4869 <a name="l4849"><span class="ln">4849 </span></a>            <span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens = self.expr._parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
4870 <a name="l4850"><span class="ln">4850 </span></a>        <span class="s3">except </span><span class="s1">(ParseException</span><span class="s3">, </span><span class="s1">IndexError):</span>
4871 <a name="l4851"><span class="ln">4851 </span></a>            <span class="s3">if </span><span class="s1">self.defaultValue </span><span class="s3">is not </span><span class="s1">self.__optionalNotMatched:</span>
4872 <a name="l4852"><span class="ln">4852 </span></a>                <span class="s3">if </span><span class="s1">self.expr.resultsName:</span>
4873 <a name="l4853"><span class="ln">4853 </span></a>                    <span class="s1">tokens = ParseResults([self.defaultValue])</span>
4874 <a name="l4854"><span class="ln">4854 </span></a>                    <span class="s1">tokens[self.expr.resultsName] = self.defaultValue</span>
4875 <a name="l4855"><span class="ln">4855 </span></a>                <span class="s3">else</span><span class="s1">:</span>
4876 <a name="l4856"><span class="ln">4856 </span></a>                    <span class="s1">tokens = [self.defaultValue]</span>
4877 <a name="l4857"><span class="ln">4857 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4878 <a name="l4858"><span class="ln">4858 </span></a>                <span class="s1">tokens = []</span>
4879 <a name="l4859"><span class="ln">4859 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokens</span>
4880 <a name="l4860"><span class="ln">4860 </span></a>
4881 <a name="l4861"><span class="ln">4861 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
4882 <a name="l4862"><span class="ln">4862 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
4883 <a name="l4863"><span class="ln">4863 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
4884 <a name="l4864"><span class="ln">4864 </span></a>
4885 <a name="l4865"><span class="ln">4865 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is None</span><span class="s1">:</span>
4886 <a name="l4866"><span class="ln">4866 </span></a>            <span class="s1">self.strRepr = </span><span class="s2">&quot;[&quot; </span><span class="s1">+ _ustr(self.expr) + </span><span class="s2">&quot;]&quot;</span>
4887 <a name="l4867"><span class="ln">4867 </span></a>
4888 <a name="l4868"><span class="ln">4868 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
4889 <a name="l4869"><span class="ln">4869 </span></a>
4890 <a name="l4870"><span class="ln">4870 </span></a><span class="s3">class </span><span class="s1">SkipTo(ParseElementEnhance):</span>
4891 <a name="l4871"><span class="ln">4871 </span></a>    <span class="s5">&quot;&quot;&quot;Token for skipping over all undefined text until the matched 
4892 <a name="l4872"><span class="ln">4872 </span></a>    expression is found. 
4893 <a name="l4873"><span class="ln">4873 </span></a> 
4894 <a name="l4874"><span class="ln">4874 </span></a>    Parameters: 
4895 <a name="l4875"><span class="ln">4875 </span></a>     - expr - target expression marking the end of the data to be skipped 
4896 <a name="l4876"><span class="ln">4876 </span></a>     - include - (default= ``False``) if True, the target expression is also parsed 
4897 <a name="l4877"><span class="ln">4877 </span></a>          (the skipped text and target expression are returned as a 2-element list). 
4898 <a name="l4878"><span class="ln">4878 </span></a>     - ignore - (default= ``None``) used to define grammars (typically quoted strings and 
4899 <a name="l4879"><span class="ln">4879 </span></a>          comments) that might contain false matches to the target expression 
4900 <a name="l4880"><span class="ln">4880 </span></a>     - failOn - (default= ``None``) define expressions that are not allowed to be 
4901 <a name="l4881"><span class="ln">4881 </span></a>          included in the skipped test; if found before the target expression is found, 
4902 <a name="l4882"><span class="ln">4882 </span></a>          the SkipTo is not a match 
4903 <a name="l4883"><span class="ln">4883 </span></a> 
4904 <a name="l4884"><span class="ln">4884 </span></a>    Example:: 
4905 <a name="l4885"><span class="ln">4885 </span></a> 
4906 <a name="l4886"><span class="ln">4886 </span></a>        report = ''' 
4907 <a name="l4887"><span class="ln">4887 </span></a>            Outstanding Issues Report - 1 Jan 2000 
4908 <a name="l4888"><span class="ln">4888 </span></a> 
4909 <a name="l4889"><span class="ln">4889 </span></a>               # | Severity | Description                               |  Days Open 
4910 <a name="l4890"><span class="ln">4890 </span></a>            -----+----------+-------------------------------------------+----------- 
4911 <a name="l4891"><span class="ln">4891 </span></a>             101 | Critical | Intermittent system crash                 |          6 
4912 <a name="l4892"><span class="ln">4892 </span></a>              94 | Cosmetic | Spelling error on Login ('log|n')         |         14 
4913 <a name="l4893"><span class="ln">4893 </span></a>              79 | Minor    | System slow when running too many reports |         47 
4914 <a name="l4894"><span class="ln">4894 </span></a>            ''' 
4915 <a name="l4895"><span class="ln">4895 </span></a>        integer = Word(nums) 
4916 <a name="l4896"><span class="ln">4896 </span></a>        SEP = Suppress('|') 
4917 <a name="l4897"><span class="ln">4897 </span></a>        # use SkipTo to simply match everything up until the next SEP 
4918 <a name="l4898"><span class="ln">4898 </span></a>        # - ignore quoted strings, so that a '|' character inside a quoted string does not match 
4919 <a name="l4899"><span class="ln">4899 </span></a>        # - parse action will call token.strip() for each matched token, i.e., the description body 
4920 <a name="l4900"><span class="ln">4900 </span></a>        string_data = SkipTo(SEP, ignore=quotedString) 
4921 <a name="l4901"><span class="ln">4901 </span></a>        string_data.setParseAction(tokenMap(str.strip)) 
4922 <a name="l4902"><span class="ln">4902 </span></a>        ticket_expr = (integer(&quot;issue_num&quot;) + SEP 
4923 <a name="l4903"><span class="ln">4903 </span></a>                      + string_data(&quot;sev&quot;) + SEP 
4924 <a name="l4904"><span class="ln">4904 </span></a>                      + string_data(&quot;desc&quot;) + SEP 
4925 <a name="l4905"><span class="ln">4905 </span></a>                      + integer(&quot;days_open&quot;)) 
4926 <a name="l4906"><span class="ln">4906 </span></a> 
4927 <a name="l4907"><span class="ln">4907 </span></a>        for tkt in ticket_expr.searchString(report): 
4928 <a name="l4908"><span class="ln">4908 </span></a>            print tkt.dump() 
4929 <a name="l4909"><span class="ln">4909 </span></a> 
4930 <a name="l4910"><span class="ln">4910 </span></a>    prints:: 
4931 <a name="l4911"><span class="ln">4911 </span></a> 
4932 <a name="l4912"><span class="ln">4912 </span></a>        ['101', 'Critical', 'Intermittent system crash', '6'] 
4933 <a name="l4913"><span class="ln">4913 </span></a>        - days_open: 6 
4934 <a name="l4914"><span class="ln">4914 </span></a>        - desc: Intermittent system crash 
4935 <a name="l4915"><span class="ln">4915 </span></a>        - issue_num: 101 
4936 <a name="l4916"><span class="ln">4916 </span></a>        - sev: Critical 
4937 <a name="l4917"><span class="ln">4917 </span></a>        ['94', 'Cosmetic', &quot;Spelling error on Login ('log|n')&quot;, '14'] 
4938 <a name="l4918"><span class="ln">4918 </span></a>        - days_open: 14 
4939 <a name="l4919"><span class="ln">4919 </span></a>        - desc: Spelling error on Login ('log|n') 
4940 <a name="l4920"><span class="ln">4920 </span></a>        - issue_num: 94 
4941 <a name="l4921"><span class="ln">4921 </span></a>        - sev: Cosmetic 
4942 <a name="l4922"><span class="ln">4922 </span></a>        ['79', 'Minor', 'System slow when running too many reports', '47'] 
4943 <a name="l4923"><span class="ln">4923 </span></a>        - days_open: 47 
4944 <a name="l4924"><span class="ln">4924 </span></a>        - desc: System slow when running too many reports 
4945 <a name="l4925"><span class="ln">4925 </span></a>        - issue_num: 79 
4946 <a name="l4926"><span class="ln">4926 </span></a>        - sev: Minor 
4947 <a name="l4927"><span class="ln">4927 </span></a>    &quot;&quot;&quot;</span>
4948 <a name="l4928"><span class="ln">4928 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">other</span><span class="s3">, </span><span class="s1">include=</span><span class="s3">False, </span><span class="s1">ignore=</span><span class="s3">None, </span><span class="s1">failOn=</span><span class="s3">None</span><span class="s1">):</span>
4949 <a name="l4929"><span class="ln">4929 </span></a>        <span class="s1">super(SkipTo</span><span class="s3">, </span><span class="s1">self).__init__(other)</span>
4950 <a name="l4930"><span class="ln">4930 </span></a>        <span class="s1">self.ignoreExpr = ignore</span>
4951 <a name="l4931"><span class="ln">4931 </span></a>        <span class="s1">self.mayReturnEmpty = </span><span class="s3">True</span>
4952 <a name="l4932"><span class="ln">4932 </span></a>        <span class="s1">self.mayIndexError = </span><span class="s3">False</span>
4953 <a name="l4933"><span class="ln">4933 </span></a>        <span class="s1">self.includeMatch = include</span>
4954 <a name="l4934"><span class="ln">4934 </span></a>        <span class="s1">self.saveAsList = </span><span class="s3">False</span>
4955 <a name="l4935"><span class="ln">4935 </span></a>        <span class="s3">if </span><span class="s1">isinstance(failOn</span><span class="s3">, </span><span class="s1">basestring):</span>
4956 <a name="l4936"><span class="ln">4936 </span></a>            <span class="s1">self.failOn = self._literalStringClass(failOn)</span>
4957 <a name="l4937"><span class="ln">4937 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4958 <a name="l4938"><span class="ln">4938 </span></a>            <span class="s1">self.failOn = failOn</span>
4959 <a name="l4939"><span class="ln">4939 </span></a>        <span class="s1">self.errmsg = </span><span class="s2">&quot;No match found for &quot; </span><span class="s1">+ _ustr(self.expr)</span>
4960 <a name="l4940"><span class="ln">4940 </span></a>
4961 <a name="l4941"><span class="ln">4941 </span></a>    <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
4962 <a name="l4942"><span class="ln">4942 </span></a>        <span class="s1">startloc = loc</span>
4963 <a name="l4943"><span class="ln">4943 </span></a>        <span class="s1">instrlen = len(instring)</span>
4964 <a name="l4944"><span class="ln">4944 </span></a>        <span class="s1">expr = self.expr</span>
4965 <a name="l4945"><span class="ln">4945 </span></a>        <span class="s1">expr_parse = self.expr._parse</span>
4966 <a name="l4946"><span class="ln">4946 </span></a>        <span class="s1">self_failOn_canParseNext = self.failOn.canParseNext </span><span class="s3">if </span><span class="s1">self.failOn </span><span class="s3">is not None else None</span>
4967 <a name="l4947"><span class="ln">4947 </span></a>        <span class="s1">self_ignoreExpr_tryParse = self.ignoreExpr.tryParse </span><span class="s3">if </span><span class="s1">self.ignoreExpr </span><span class="s3">is not None else None</span>
4968 <a name="l4948"><span class="ln">4948 </span></a>
4969 <a name="l4949"><span class="ln">4949 </span></a>        <span class="s1">tmploc = loc</span>
4970 <a name="l4950"><span class="ln">4950 </span></a>        <span class="s3">while </span><span class="s1">tmploc &lt;= instrlen:</span>
4971 <a name="l4951"><span class="ln">4951 </span></a>            <span class="s3">if </span><span class="s1">self_failOn_canParseNext </span><span class="s3">is not None</span><span class="s1">:</span>
4972 <a name="l4952"><span class="ln">4952 </span></a>                <span class="s0"># break if failOn expression matches</span>
4973 <a name="l4953"><span class="ln">4953 </span></a>                <span class="s3">if </span><span class="s1">self_failOn_canParseNext(instring</span><span class="s3">, </span><span class="s1">tmploc):</span>
4974 <a name="l4954"><span class="ln">4954 </span></a>                    <span class="s3">break</span>
4975 <a name="l4955"><span class="ln">4955 </span></a>
4976 <a name="l4956"><span class="ln">4956 </span></a>            <span class="s3">if </span><span class="s1">self_ignoreExpr_tryParse </span><span class="s3">is not None</span><span class="s1">:</span>
4977 <a name="l4957"><span class="ln">4957 </span></a>                <span class="s0"># advance past ignore expressions</span>
4978 <a name="l4958"><span class="ln">4958 </span></a>                <span class="s3">while </span><span class="s4">1</span><span class="s1">:</span>
4979 <a name="l4959"><span class="ln">4959 </span></a>                    <span class="s3">try</span><span class="s1">:</span>
4980 <a name="l4960"><span class="ln">4960 </span></a>                        <span class="s1">tmploc = self_ignoreExpr_tryParse(instring</span><span class="s3">, </span><span class="s1">tmploc)</span>
4981 <a name="l4961"><span class="ln">4961 </span></a>                    <span class="s3">except </span><span class="s1">ParseBaseException:</span>
4982 <a name="l4962"><span class="ln">4962 </span></a>                        <span class="s3">break</span>
4983 <a name="l4963"><span class="ln">4963 </span></a>
4984 <a name="l4964"><span class="ln">4964 </span></a>            <span class="s3">try</span><span class="s1">:</span>
4985 <a name="l4965"><span class="ln">4965 </span></a>                <span class="s1">expr_parse(instring</span><span class="s3">, </span><span class="s1">tmploc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">False, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
4986 <a name="l4966"><span class="ln">4966 </span></a>            <span class="s3">except </span><span class="s1">(ParseException</span><span class="s3">, </span><span class="s1">IndexError):</span>
4987 <a name="l4967"><span class="ln">4967 </span></a>                <span class="s0"># no match, advance loc in string</span>
4988 <a name="l4968"><span class="ln">4968 </span></a>                <span class="s1">tmploc += </span><span class="s4">1</span>
4989 <a name="l4969"><span class="ln">4969 </span></a>            <span class="s3">else</span><span class="s1">:</span>
4990 <a name="l4970"><span class="ln">4970 </span></a>                <span class="s0"># matched skipto expr, done</span>
4991 <a name="l4971"><span class="ln">4971 </span></a>                <span class="s3">break</span>
4992 <a name="l4972"><span class="ln">4972 </span></a>
4993 <a name="l4973"><span class="ln">4973 </span></a>        <span class="s3">else</span><span class="s1">:</span>
4994 <a name="l4974"><span class="ln">4974 </span></a>            <span class="s0"># ran off the end of the input string without matching skipto expr, fail</span>
4995 <a name="l4975"><span class="ln">4975 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">self.errmsg</span><span class="s3">, </span><span class="s1">self)</span>
4996 <a name="l4976"><span class="ln">4976 </span></a>
4997 <a name="l4977"><span class="ln">4977 </span></a>        <span class="s0"># build up return values</span>
4998 <a name="l4978"><span class="ln">4978 </span></a>        <span class="s1">loc = tmploc</span>
4999 <a name="l4979"><span class="ln">4979 </span></a>        <span class="s1">skiptext = instring[startloc:loc]</span>
5000 <a name="l4980"><span class="ln">4980 </span></a>        <span class="s1">skipresult = ParseResults(skiptext)</span>
5001 <a name="l4981"><span class="ln">4981 </span></a>
5002 <a name="l4982"><span class="ln">4982 </span></a>        <span class="s3">if </span><span class="s1">self.includeMatch:</span>
5003 <a name="l4983"><span class="ln">4983 </span></a>            <span class="s1">loc</span><span class="s3">, </span><span class="s1">mat = expr_parse(instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions</span><span class="s3">, </span><span class="s1">callPreParse=</span><span class="s3">False</span><span class="s1">)</span>
5004 <a name="l4984"><span class="ln">4984 </span></a>            <span class="s1">skipresult += mat</span>
5005 <a name="l4985"><span class="ln">4985 </span></a>
5006 <a name="l4986"><span class="ln">4986 </span></a>        <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">skipresult</span>
5007 <a name="l4987"><span class="ln">4987 </span></a>
5008 <a name="l4988"><span class="ln">4988 </span></a><span class="s3">class </span><span class="s1">Forward(ParseElementEnhance):</span>
5009 <a name="l4989"><span class="ln">4989 </span></a>    <span class="s5">&quot;&quot;&quot;Forward declaration of an expression to be defined later - 
5010 <a name="l4990"><span class="ln">4990 </span></a>    used for recursive grammars, such as algebraic infix notation. 
5011 <a name="l4991"><span class="ln">4991 </span></a>    When the expression is known, it is assigned to the ``Forward`` 
5012 <a name="l4992"><span class="ln">4992 </span></a>    variable using the '&lt;&lt;' operator. 
5013 <a name="l4993"><span class="ln">4993 </span></a> 
5014 <a name="l4994"><span class="ln">4994 </span></a>    Note: take care when assigning to ``Forward`` not to overlook 
5015 <a name="l4995"><span class="ln">4995 </span></a>    precedence of operators. 
5016 <a name="l4996"><span class="ln">4996 </span></a> 
5017 <a name="l4997"><span class="ln">4997 </span></a>    Specifically, '|' has a lower precedence than '&lt;&lt;', so that:: 
5018 <a name="l4998"><span class="ln">4998 </span></a> 
5019 <a name="l4999"><span class="ln">4999 </span></a>        fwdExpr &lt;&lt; a | b | c 
5020 <a name="l5000"><span class="ln">5000 </span></a> 
5021 <a name="l5001"><span class="ln">5001 </span></a>    will actually be evaluated as:: 
5022 <a name="l5002"><span class="ln">5002 </span></a> 
5023 <a name="l5003"><span class="ln">5003 </span></a>        (fwdExpr &lt;&lt; a) | b | c 
5024 <a name="l5004"><span class="ln">5004 </span></a> 
5025 <a name="l5005"><span class="ln">5005 </span></a>    thereby leaving b and c out as parseable alternatives.  It is recommended that you 
5026 <a name="l5006"><span class="ln">5006 </span></a>    explicitly group the values inserted into the ``Forward``:: 
5027 <a name="l5007"><span class="ln">5007 </span></a> 
5028 <a name="l5008"><span class="ln">5008 </span></a>        fwdExpr &lt;&lt; (a | b | c) 
5029 <a name="l5009"><span class="ln">5009 </span></a> 
5030 <a name="l5010"><span class="ln">5010 </span></a>    Converting to use the '&lt;&lt;=' operator instead will avoid this problem. 
5031 <a name="l5011"><span class="ln">5011 </span></a> 
5032 <a name="l5012"><span class="ln">5012 </span></a>    See :class:`ParseResults.pprint` for an example of a recursive 
5033 <a name="l5013"><span class="ln">5013 </span></a>    parser created using ``Forward``. 
5034 <a name="l5014"><span class="ln">5014 </span></a>    &quot;&quot;&quot;</span>
5035 <a name="l5015"><span class="ln">5015 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">other=</span><span class="s3">None</span><span class="s1">):</span>
5036 <a name="l5016"><span class="ln">5016 </span></a>        <span class="s1">super(Forward</span><span class="s3">, </span><span class="s1">self).__init__(other</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">)</span>
5037 <a name="l5017"><span class="ln">5017 </span></a>
5038 <a name="l5018"><span class="ln">5018 </span></a>    <span class="s3">def </span><span class="s1">__lshift__(self</span><span class="s3">, </span><span class="s1">other):</span>
5039 <a name="l5019"><span class="ln">5019 </span></a>        <span class="s3">if </span><span class="s1">isinstance(other</span><span class="s3">, </span><span class="s1">basestring):</span>
5040 <a name="l5020"><span class="ln">5020 </span></a>            <span class="s1">other = self._literalStringClass(other)</span>
5041 <a name="l5021"><span class="ln">5021 </span></a>        <span class="s1">self.expr = other</span>
5042 <a name="l5022"><span class="ln">5022 </span></a>        <span class="s1">self.strRepr = </span><span class="s3">None</span>
5043 <a name="l5023"><span class="ln">5023 </span></a>        <span class="s1">self.mayIndexError = self.expr.mayIndexError</span>
5044 <a name="l5024"><span class="ln">5024 </span></a>        <span class="s1">self.mayReturnEmpty = self.expr.mayReturnEmpty</span>
5045 <a name="l5025"><span class="ln">5025 </span></a>        <span class="s1">self.setWhitespaceChars(self.expr.whiteChars)</span>
5046 <a name="l5026"><span class="ln">5026 </span></a>        <span class="s1">self.skipWhitespace = self.expr.skipWhitespace</span>
5047 <a name="l5027"><span class="ln">5027 </span></a>        <span class="s1">self.saveAsList = self.expr.saveAsList</span>
5048 <a name="l5028"><span class="ln">5028 </span></a>        <span class="s1">self.ignoreExprs.extend(self.expr.ignoreExprs)</span>
5049 <a name="l5029"><span class="ln">5029 </span></a>        <span class="s3">return </span><span class="s1">self</span>
5050 <a name="l5030"><span class="ln">5030 </span></a>
5051 <a name="l5031"><span class="ln">5031 </span></a>    <span class="s3">def </span><span class="s1">__ilshift__(self</span><span class="s3">, </span><span class="s1">other):</span>
5052 <a name="l5032"><span class="ln">5032 </span></a>        <span class="s3">return </span><span class="s1">self &lt;&lt; other</span>
5053 <a name="l5033"><span class="ln">5033 </span></a>
5054 <a name="l5034"><span class="ln">5034 </span></a>    <span class="s3">def </span><span class="s1">leaveWhitespace(self):</span>
5055 <a name="l5035"><span class="ln">5035 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">False</span>
5056 <a name="l5036"><span class="ln">5036 </span></a>        <span class="s3">return </span><span class="s1">self</span>
5057 <a name="l5037"><span class="ln">5037 </span></a>
5058 <a name="l5038"><span class="ln">5038 </span></a>    <span class="s3">def </span><span class="s1">streamline(self):</span>
5059 <a name="l5039"><span class="ln">5039 </span></a>        <span class="s3">if not </span><span class="s1">self.streamlined:</span>
5060 <a name="l5040"><span class="ln">5040 </span></a>            <span class="s1">self.streamlined = </span><span class="s3">True</span>
5061 <a name="l5041"><span class="ln">5041 </span></a>            <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
5062 <a name="l5042"><span class="ln">5042 </span></a>                <span class="s1">self.expr.streamline()</span>
5063 <a name="l5043"><span class="ln">5043 </span></a>        <span class="s3">return </span><span class="s1">self</span>
5064 <a name="l5044"><span class="ln">5044 </span></a>
5065 <a name="l5045"><span class="ln">5045 </span></a>    <span class="s3">def </span><span class="s1">validate(self</span><span class="s3">, </span><span class="s1">validateTrace=</span><span class="s3">None</span><span class="s1">):</span>
5066 <a name="l5046"><span class="ln">5046 </span></a>        <span class="s3">if </span><span class="s1">validateTrace </span><span class="s3">is None</span><span class="s1">:</span>
5067 <a name="l5047"><span class="ln">5047 </span></a>            <span class="s1">validateTrace = []</span>
5068 <a name="l5048"><span class="ln">5048 </span></a>
5069 <a name="l5049"><span class="ln">5049 </span></a>        <span class="s3">if </span><span class="s1">self </span><span class="s3">not in </span><span class="s1">validateTrace:</span>
5070 <a name="l5050"><span class="ln">5050 </span></a>            <span class="s1">tmp = validateTrace[:] + [self]</span>
5071 <a name="l5051"><span class="ln">5051 </span></a>            <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
5072 <a name="l5052"><span class="ln">5052 </span></a>                <span class="s1">self.expr.validate(tmp)</span>
5073 <a name="l5053"><span class="ln">5053 </span></a>        <span class="s1">self.checkRecursion([])</span>
5074 <a name="l5054"><span class="ln">5054 </span></a>
5075 <a name="l5055"><span class="ln">5055 </span></a>    <span class="s3">def </span><span class="s1">__str__(self):</span>
5076 <a name="l5056"><span class="ln">5056 </span></a>        <span class="s3">if </span><span class="s1">hasattr(self</span><span class="s3">, </span><span class="s2">&quot;name&quot;</span><span class="s1">):</span>
5077 <a name="l5057"><span class="ln">5057 </span></a>            <span class="s3">return </span><span class="s1">self.name</span>
5078 <a name="l5058"><span class="ln">5058 </span></a>        <span class="s3">if </span><span class="s1">self.strRepr </span><span class="s3">is not None</span><span class="s1">:</span>
5079 <a name="l5059"><span class="ln">5059 </span></a>            <span class="s3">return </span><span class="s1">self.strRepr</span>
5080 <a name="l5060"><span class="ln">5060 </span></a>
5081 <a name="l5061"><span class="ln">5061 </span></a>        <span class="s0"># Avoid infinite recursion by setting a temporary strRepr</span>
5082 <a name="l5062"><span class="ln">5062 </span></a>        <span class="s1">self.strRepr = </span><span class="s2">&quot;: ...&quot;</span>
5083 <a name="l5063"><span class="ln">5063 </span></a>
5084 <a name="l5064"><span class="ln">5064 </span></a>        <span class="s0"># Use the string representation of main expression.</span>
5085 <a name="l5065"><span class="ln">5065 </span></a>        <span class="s1">retString = </span><span class="s2">'...'</span>
5086 <a name="l5066"><span class="ln">5066 </span></a>        <span class="s3">try</span><span class="s1">:</span>
5087 <a name="l5067"><span class="ln">5067 </span></a>            <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
5088 <a name="l5068"><span class="ln">5068 </span></a>                <span class="s1">retString = _ustr(self.expr)[:</span><span class="s4">1000</span><span class="s1">]</span>
5089 <a name="l5069"><span class="ln">5069 </span></a>            <span class="s3">else</span><span class="s1">:</span>
5090 <a name="l5070"><span class="ln">5070 </span></a>                <span class="s1">retString = </span><span class="s2">&quot;None&quot;</span>
5091 <a name="l5071"><span class="ln">5071 </span></a>        <span class="s3">finally</span><span class="s1">:</span>
5092 <a name="l5072"><span class="ln">5072 </span></a>            <span class="s1">self.strRepr = self.__class__.__name__ + </span><span class="s2">&quot;: &quot; </span><span class="s1">+ retString</span>
5093 <a name="l5073"><span class="ln">5073 </span></a>        <span class="s3">return </span><span class="s1">self.strRepr</span>
5094 <a name="l5074"><span class="ln">5074 </span></a>
5095 <a name="l5075"><span class="ln">5075 </span></a>    <span class="s3">def </span><span class="s1">copy(self):</span>
5096 <a name="l5076"><span class="ln">5076 </span></a>        <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is not None</span><span class="s1">:</span>
5097 <a name="l5077"><span class="ln">5077 </span></a>            <span class="s3">return </span><span class="s1">super(Forward</span><span class="s3">, </span><span class="s1">self).copy()</span>
5098 <a name="l5078"><span class="ln">5078 </span></a>        <span class="s3">else</span><span class="s1">:</span>
5099 <a name="l5079"><span class="ln">5079 </span></a>            <span class="s1">ret = Forward()</span>
5100 <a name="l5080"><span class="ln">5080 </span></a>            <span class="s1">ret &lt;&lt;= self</span>
5101 <a name="l5081"><span class="ln">5081 </span></a>            <span class="s3">return </span><span class="s1">ret</span>
5102 <a name="l5082"><span class="ln">5082 </span></a>
5103 <a name="l5083"><span class="ln">5083 </span></a>    <span class="s3">def </span><span class="s1">_setResultsName(self</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">listAllMatches=</span><span class="s3">False</span><span class="s1">):</span>
5104 <a name="l5084"><span class="ln">5084 </span></a>        <span class="s3">if </span><span class="s1">__diag__.warn_name_set_on_empty_Forward:</span>
5105 <a name="l5085"><span class="ln">5085 </span></a>            <span class="s3">if </span><span class="s1">self.expr </span><span class="s3">is None</span><span class="s1">:</span>
5106 <a name="l5086"><span class="ln">5086 </span></a>                <span class="s1">warnings.warn(</span><span class="s2">&quot;{0}: setting results name {0!r} on {1} expression &quot;</span>
5107 <a name="l5087"><span class="ln">5087 </span></a>                              <span class="s2">&quot;that has no contained expression&quot;</span><span class="s1">.format(</span><span class="s2">&quot;warn_name_set_on_empty_Forward&quot;</span><span class="s3">,</span>
5108 <a name="l5088"><span class="ln">5088 </span></a>                                                                        <span class="s1">name</span><span class="s3">,</span>
5109 <a name="l5089"><span class="ln">5089 </span></a>                                                                        <span class="s1">type(self).__name__)</span><span class="s3">,</span>
5110 <a name="l5090"><span class="ln">5090 </span></a>                              <span class="s1">stacklevel=</span><span class="s4">3</span><span class="s1">)</span>
5111 <a name="l5091"><span class="ln">5091 </span></a>
5112 <a name="l5092"><span class="ln">5092 </span></a>        <span class="s3">return </span><span class="s1">super(Forward</span><span class="s3">, </span><span class="s1">self)._setResultsName(name</span><span class="s3">, </span><span class="s1">listAllMatches)</span>
5113 <a name="l5093"><span class="ln">5093 </span></a>
5114 <a name="l5094"><span class="ln">5094 </span></a><span class="s3">class </span><span class="s1">TokenConverter(ParseElementEnhance):</span>
5115 <a name="l5095"><span class="ln">5095 </span></a>    <span class="s5">&quot;&quot;&quot; 
5116 <a name="l5096"><span class="ln">5096 </span></a>    Abstract subclass of :class:`ParseExpression`, for converting parsed results. 
5117 <a name="l5097"><span class="ln">5097 </span></a>    &quot;&quot;&quot;</span>
5118 <a name="l5098"><span class="ln">5098 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">savelist=</span><span class="s3">False</span><span class="s1">):</span>
5119 <a name="l5099"><span class="ln">5099 </span></a>        <span class="s1">super(TokenConverter</span><span class="s3">, </span><span class="s1">self).__init__(expr)  </span><span class="s0"># , savelist)</span>
5120 <a name="l5100"><span class="ln">5100 </span></a>        <span class="s1">self.saveAsList = </span><span class="s3">False</span>
5121 <a name="l5101"><span class="ln">5101 </span></a>
5122 <a name="l5102"><span class="ln">5102 </span></a><span class="s3">class </span><span class="s1">Combine(TokenConverter):</span>
5123 <a name="l5103"><span class="ln">5103 </span></a>    <span class="s5">&quot;&quot;&quot;Converter to concatenate all matching tokens to a single string. 
5124 <a name="l5104"><span class="ln">5104 </span></a>    By default, the matching patterns must also be contiguous in the 
5125 <a name="l5105"><span class="ln">5105 </span></a>    input string; this can be disabled by specifying 
5126 <a name="l5106"><span class="ln">5106 </span></a>    ``'adjacent=False'`` in the constructor. 
5127 <a name="l5107"><span class="ln">5107 </span></a> 
5128 <a name="l5108"><span class="ln">5108 </span></a>    Example:: 
5129 <a name="l5109"><span class="ln">5109 </span></a> 
5130 <a name="l5110"><span class="ln">5110 </span></a>        real = Word(nums) + '.' + Word(nums) 
5131 <a name="l5111"><span class="ln">5111 </span></a>        print(real.parseString('3.1416')) # -&gt; ['3', '.', '1416'] 
5132 <a name="l5112"><span class="ln">5112 </span></a>        # will also erroneously match the following 
5133 <a name="l5113"><span class="ln">5113 </span></a>        print(real.parseString('3. 1416')) # -&gt; ['3', '.', '1416'] 
5134 <a name="l5114"><span class="ln">5114 </span></a> 
5135 <a name="l5115"><span class="ln">5115 </span></a>        real = Combine(Word(nums) + '.' + Word(nums)) 
5136 <a name="l5116"><span class="ln">5116 </span></a>        print(real.parseString('3.1416')) # -&gt; ['3.1416'] 
5137 <a name="l5117"><span class="ln">5117 </span></a>        # no match when there are internal spaces 
5138 <a name="l5118"><span class="ln">5118 </span></a>        print(real.parseString('3. 1416')) # -&gt; Exception: Expected W:(0123...) 
5139 <a name="l5119"><span class="ln">5119 </span></a>    &quot;&quot;&quot;</span>
5140 <a name="l5120"><span class="ln">5120 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">joinString=</span><span class="s2">&quot;&quot;</span><span class="s3">, </span><span class="s1">adjacent=</span><span class="s3">True</span><span class="s1">):</span>
5141 <a name="l5121"><span class="ln">5121 </span></a>        <span class="s1">super(Combine</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
5142 <a name="l5122"><span class="ln">5122 </span></a>        <span class="s0"># suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself</span>
5143 <a name="l5123"><span class="ln">5123 </span></a>        <span class="s3">if </span><span class="s1">adjacent:</span>
5144 <a name="l5124"><span class="ln">5124 </span></a>            <span class="s1">self.leaveWhitespace()</span>
5145 <a name="l5125"><span class="ln">5125 </span></a>        <span class="s1">self.adjacent = adjacent</span>
5146 <a name="l5126"><span class="ln">5126 </span></a>        <span class="s1">self.skipWhitespace = </span><span class="s3">True</span>
5147 <a name="l5127"><span class="ln">5127 </span></a>        <span class="s1">self.joinString = joinString</span>
5148 <a name="l5128"><span class="ln">5128 </span></a>        <span class="s1">self.callPreparse = </span><span class="s3">True</span>
5149 <a name="l5129"><span class="ln">5129 </span></a>
5150 <a name="l5130"><span class="ln">5130 </span></a>    <span class="s3">def </span><span class="s1">ignore(self</span><span class="s3">, </span><span class="s1">other):</span>
5151 <a name="l5131"><span class="ln">5131 </span></a>        <span class="s3">if </span><span class="s1">self.adjacent:</span>
5152 <a name="l5132"><span class="ln">5132 </span></a>            <span class="s1">ParserElement.ignore(self</span><span class="s3">, </span><span class="s1">other)</span>
5153 <a name="l5133"><span class="ln">5133 </span></a>        <span class="s3">else</span><span class="s1">:</span>
5154 <a name="l5134"><span class="ln">5134 </span></a>            <span class="s1">super(Combine</span><span class="s3">, </span><span class="s1">self).ignore(other)</span>
5155 <a name="l5135"><span class="ln">5135 </span></a>        <span class="s3">return </span><span class="s1">self</span>
5156 <a name="l5136"><span class="ln">5136 </span></a>
5157 <a name="l5137"><span class="ln">5137 </span></a>    <span class="s3">def </span><span class="s1">postParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokenlist):</span>
5158 <a name="l5138"><span class="ln">5138 </span></a>        <span class="s1">retToks = tokenlist.copy()</span>
5159 <a name="l5139"><span class="ln">5139 </span></a>        <span class="s3">del </span><span class="s1">retToks[:]</span>
5160 <a name="l5140"><span class="ln">5140 </span></a>        <span class="s1">retToks += ParseResults([</span><span class="s2">&quot;&quot;</span><span class="s1">.join(tokenlist._asStringList(self.joinString))]</span><span class="s3">, </span><span class="s1">modal=self.modalResults)</span>
5161 <a name="l5141"><span class="ln">5141 </span></a>
5162 <a name="l5142"><span class="ln">5142 </span></a>        <span class="s3">if </span><span class="s1">self.resultsName </span><span class="s3">and </span><span class="s1">retToks.haskeys():</span>
5163 <a name="l5143"><span class="ln">5143 </span></a>            <span class="s3">return </span><span class="s1">[retToks]</span>
5164 <a name="l5144"><span class="ln">5144 </span></a>        <span class="s3">else</span><span class="s1">:</span>
5165 <a name="l5145"><span class="ln">5145 </span></a>            <span class="s3">return </span><span class="s1">retToks</span>
5166 <a name="l5146"><span class="ln">5146 </span></a>
5167 <a name="l5147"><span class="ln">5147 </span></a><span class="s3">class </span><span class="s1">Group(TokenConverter):</span>
5168 <a name="l5148"><span class="ln">5148 </span></a>    <span class="s5">&quot;&quot;&quot;Converter to return the matched tokens as a list - useful for 
5169 <a name="l5149"><span class="ln">5149 </span></a>    returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions. 
5170 <a name="l5150"><span class="ln">5150 </span></a> 
5171 <a name="l5151"><span class="ln">5151 </span></a>    Example:: 
5172 <a name="l5152"><span class="ln">5152 </span></a> 
5173 <a name="l5153"><span class="ln">5153 </span></a>        ident = Word(alphas) 
5174 <a name="l5154"><span class="ln">5154 </span></a>        num = Word(nums) 
5175 <a name="l5155"><span class="ln">5155 </span></a>        term = ident | num 
5176 <a name="l5156"><span class="ln">5156 </span></a>        func = ident + Optional(delimitedList(term)) 
5177 <a name="l5157"><span class="ln">5157 </span></a>        print(func.parseString(&quot;fn a, b, 100&quot;))  # -&gt; ['fn', 'a', 'b', '100'] 
5178 <a name="l5158"><span class="ln">5158 </span></a> 
5179 <a name="l5159"><span class="ln">5159 </span></a>        func = ident + Group(Optional(delimitedList(term))) 
5180 <a name="l5160"><span class="ln">5160 </span></a>        print(func.parseString(&quot;fn a, b, 100&quot;))  # -&gt; ['fn', ['a', 'b', '100']] 
5181 <a name="l5161"><span class="ln">5161 </span></a>    &quot;&quot;&quot;</span>
5182 <a name="l5162"><span class="ln">5162 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr):</span>
5183 <a name="l5163"><span class="ln">5163 </span></a>        <span class="s1">super(Group</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
5184 <a name="l5164"><span class="ln">5164 </span></a>        <span class="s1">self.saveAsList = </span><span class="s3">True</span>
5185 <a name="l5165"><span class="ln">5165 </span></a>
5186 <a name="l5166"><span class="ln">5166 </span></a>    <span class="s3">def </span><span class="s1">postParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokenlist):</span>
5187 <a name="l5167"><span class="ln">5167 </span></a>        <span class="s3">return </span><span class="s1">[tokenlist]</span>
5188 <a name="l5168"><span class="ln">5168 </span></a>
5189 <a name="l5169"><span class="ln">5169 </span></a><span class="s3">class </span><span class="s1">Dict(TokenConverter):</span>
5190 <a name="l5170"><span class="ln">5170 </span></a>    <span class="s5">&quot;&quot;&quot;Converter to return a repetitive expression as a list, but also 
5191 <a name="l5171"><span class="ln">5171 </span></a>    as a dictionary. Each element can also be referenced using the first 
5192 <a name="l5172"><span class="ln">5172 </span></a>    token in the expression as its key. Useful for tabular report 
5193 <a name="l5173"><span class="ln">5173 </span></a>    scraping when the first column can be used as a item key. 
5194 <a name="l5174"><span class="ln">5174 </span></a> 
5195 <a name="l5175"><span class="ln">5175 </span></a>    Example:: 
5196 <a name="l5176"><span class="ln">5176 </span></a> 
5197 <a name="l5177"><span class="ln">5177 </span></a>        data_word = Word(alphas) 
5198 <a name="l5178"><span class="ln">5178 </span></a>        label = data_word + FollowedBy(':') 
5199 <a name="l5179"><span class="ln">5179 </span></a>        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) 
5200 <a name="l5180"><span class="ln">5180 </span></a> 
5201 <a name="l5181"><span class="ln">5181 </span></a>        text = &quot;shape: SQUARE posn: upper left color: light blue texture: burlap&quot; 
5202 <a name="l5182"><span class="ln">5182 </span></a>        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
5203 <a name="l5183"><span class="ln">5183 </span></a> 
5204 <a name="l5184"><span class="ln">5184 </span></a>        # print attributes as plain groups 
5205 <a name="l5185"><span class="ln">5185 </span></a>        print(OneOrMore(attr_expr).parseString(text).dump()) 
5206 <a name="l5186"><span class="ln">5186 </span></a> 
5207 <a name="l5187"><span class="ln">5187 </span></a>        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names 
5208 <a name="l5188"><span class="ln">5188 </span></a>        result = Dict(OneOrMore(Group(attr_expr))).parseString(text) 
5209 <a name="l5189"><span class="ln">5189 </span></a>        print(result.dump()) 
5210 <a name="l5190"><span class="ln">5190 </span></a> 
5211 <a name="l5191"><span class="ln">5191 </span></a>        # access named fields as dict entries, or output as dict 
5212 <a name="l5192"><span class="ln">5192 </span></a>        print(result['shape']) 
5213 <a name="l5193"><span class="ln">5193 </span></a>        print(result.asDict()) 
5214 <a name="l5194"><span class="ln">5194 </span></a> 
5215 <a name="l5195"><span class="ln">5195 </span></a>    prints:: 
5216 <a name="l5196"><span class="ln">5196 </span></a> 
5217 <a name="l5197"><span class="ln">5197 </span></a>        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap'] 
5218 <a name="l5198"><span class="ln">5198 </span></a>        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 
5219 <a name="l5199"><span class="ln">5199 </span></a>        - color: light blue 
5220 <a name="l5200"><span class="ln">5200 </span></a>        - posn: upper left 
5221 <a name="l5201"><span class="ln">5201 </span></a>        - shape: SQUARE 
5222 <a name="l5202"><span class="ln">5202 </span></a>        - texture: burlap 
5223 <a name="l5203"><span class="ln">5203 </span></a>        SQUARE 
5224 <a name="l5204"><span class="ln">5204 </span></a>        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'} 
5225 <a name="l5205"><span class="ln">5205 </span></a> 
5226 <a name="l5206"><span class="ln">5206 </span></a>    See more examples at :class:`ParseResults` of accessing fields by results name. 
5227 <a name="l5207"><span class="ln">5207 </span></a>    &quot;&quot;&quot;</span>
5228 <a name="l5208"><span class="ln">5208 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">expr):</span>
5229 <a name="l5209"><span class="ln">5209 </span></a>        <span class="s1">super(Dict</span><span class="s3">, </span><span class="s1">self).__init__(expr)</span>
5230 <a name="l5210"><span class="ln">5210 </span></a>        <span class="s1">self.saveAsList = </span><span class="s3">True</span>
5231 <a name="l5211"><span class="ln">5211 </span></a>
5232 <a name="l5212"><span class="ln">5212 </span></a>    <span class="s3">def </span><span class="s1">postParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokenlist):</span>
5233 <a name="l5213"><span class="ln">5213 </span></a>        <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">tok </span><span class="s3">in </span><span class="s1">enumerate(tokenlist):</span>
5234 <a name="l5214"><span class="ln">5214 </span></a>            <span class="s3">if </span><span class="s1">len(tok) == </span><span class="s4">0</span><span class="s1">:</span>
5235 <a name="l5215"><span class="ln">5215 </span></a>                <span class="s3">continue</span>
5236 <a name="l5216"><span class="ln">5216 </span></a>            <span class="s1">ikey = tok[</span><span class="s4">0</span><span class="s1">]</span>
5237 <a name="l5217"><span class="ln">5217 </span></a>            <span class="s3">if </span><span class="s1">isinstance(ikey</span><span class="s3">, </span><span class="s1">int):</span>
5238 <a name="l5218"><span class="ln">5218 </span></a>                <span class="s1">ikey = _ustr(tok[</span><span class="s4">0</span><span class="s1">]).strip()</span>
5239 <a name="l5219"><span class="ln">5219 </span></a>            <span class="s3">if </span><span class="s1">len(tok) == </span><span class="s4">1</span><span class="s1">:</span>
5240 <a name="l5220"><span class="ln">5220 </span></a>                <span class="s1">tokenlist[ikey] = _ParseResultsWithOffset(</span><span class="s2">&quot;&quot;</span><span class="s3">, </span><span class="s1">i)</span>
5241 <a name="l5221"><span class="ln">5221 </span></a>            <span class="s3">elif </span><span class="s1">len(tok) == </span><span class="s4">2 </span><span class="s3">and not </span><span class="s1">isinstance(tok[</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">ParseResults):</span>
5242 <a name="l5222"><span class="ln">5222 </span></a>                <span class="s1">tokenlist[ikey] = _ParseResultsWithOffset(tok[</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">i)</span>
5243 <a name="l5223"><span class="ln">5223 </span></a>            <span class="s3">else</span><span class="s1">:</span>
5244 <a name="l5224"><span class="ln">5224 </span></a>                <span class="s1">dictvalue = tok.copy()  </span><span class="s0"># ParseResults(i)</span>
5245 <a name="l5225"><span class="ln">5225 </span></a>                <span class="s3">del </span><span class="s1">dictvalue[</span><span class="s4">0</span><span class="s1">]</span>
5246 <a name="l5226"><span class="ln">5226 </span></a>                <span class="s3">if </span><span class="s1">len(dictvalue) != </span><span class="s4">1 </span><span class="s3">or </span><span class="s1">(isinstance(dictvalue</span><span class="s3">, </span><span class="s1">ParseResults) </span><span class="s3">and </span><span class="s1">dictvalue.haskeys()):</span>
5247 <a name="l5227"><span class="ln">5227 </span></a>                    <span class="s1">tokenlist[ikey] = _ParseResultsWithOffset(dictvalue</span><span class="s3">, </span><span class="s1">i)</span>
5248 <a name="l5228"><span class="ln">5228 </span></a>                <span class="s3">else</span><span class="s1">:</span>
5249 <a name="l5229"><span class="ln">5229 </span></a>                    <span class="s1">tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">i)</span>
5250 <a name="l5230"><span class="ln">5230 </span></a>
5251 <a name="l5231"><span class="ln">5231 </span></a>        <span class="s3">if </span><span class="s1">self.resultsName:</span>
5252 <a name="l5232"><span class="ln">5232 </span></a>            <span class="s3">return </span><span class="s1">[tokenlist]</span>
5253 <a name="l5233"><span class="ln">5233 </span></a>        <span class="s3">else</span><span class="s1">:</span>
5254 <a name="l5234"><span class="ln">5234 </span></a>            <span class="s3">return </span><span class="s1">tokenlist</span>
5255 <a name="l5235"><span class="ln">5235 </span></a>
5256 <a name="l5236"><span class="ln">5236 </span></a>
5257 <a name="l5237"><span class="ln">5237 </span></a><span class="s3">class </span><span class="s1">Suppress(TokenConverter):</span>
5258 <a name="l5238"><span class="ln">5238 </span></a>    <span class="s5">&quot;&quot;&quot;Converter for ignoring the results of a parsed expression. 
5259 <a name="l5239"><span class="ln">5239 </span></a> 
5260 <a name="l5240"><span class="ln">5240 </span></a>    Example:: 
5261 <a name="l5241"><span class="ln">5241 </span></a> 
5262 <a name="l5242"><span class="ln">5242 </span></a>        source = &quot;a, b, c,d&quot; 
5263 <a name="l5243"><span class="ln">5243 </span></a>        wd = Word(alphas) 
5264 <a name="l5244"><span class="ln">5244 </span></a>        wd_list1 = wd + ZeroOrMore(',' + wd) 
5265 <a name="l5245"><span class="ln">5245 </span></a>        print(wd_list1.parseString(source)) 
5266 <a name="l5246"><span class="ln">5246 </span></a> 
5267 <a name="l5247"><span class="ln">5247 </span></a>        # often, delimiters that are useful during parsing are just in the 
5268 <a name="l5248"><span class="ln">5248 </span></a>        # way afterward - use Suppress to keep them out of the parsed output 
5269 <a name="l5249"><span class="ln">5249 </span></a>        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd) 
5270 <a name="l5250"><span class="ln">5250 </span></a>        print(wd_list2.parseString(source)) 
5271 <a name="l5251"><span class="ln">5251 </span></a> 
5272 <a name="l5252"><span class="ln">5252 </span></a>    prints:: 
5273 <a name="l5253"><span class="ln">5253 </span></a> 
5274 <a name="l5254"><span class="ln">5254 </span></a>        ['a', ',', 'b', ',', 'c', ',', 'd'] 
5275 <a name="l5255"><span class="ln">5255 </span></a>        ['a', 'b', 'c', 'd'] 
5276 <a name="l5256"><span class="ln">5256 </span></a> 
5277 <a name="l5257"><span class="ln">5257 </span></a>    (See also :class:`delimitedList`.) 
5278 <a name="l5258"><span class="ln">5258 </span></a>    &quot;&quot;&quot;</span>
5279 <a name="l5259"><span class="ln">5259 </span></a>    <span class="s3">def </span><span class="s1">postParse(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">tokenlist):</span>
5280 <a name="l5260"><span class="ln">5260 </span></a>        <span class="s3">return </span><span class="s1">[]</span>
5281 <a name="l5261"><span class="ln">5261 </span></a>
5282 <a name="l5262"><span class="ln">5262 </span></a>    <span class="s3">def </span><span class="s1">suppress(self):</span>
5283 <a name="l5263"><span class="ln">5263 </span></a>        <span class="s3">return </span><span class="s1">self</span>
5284 <a name="l5264"><span class="ln">5264 </span></a>
5285 <a name="l5265"><span class="ln">5265 </span></a>
5286 <a name="l5266"><span class="ln">5266 </span></a><span class="s3">class </span><span class="s1">OnlyOnce(object):</span>
5287 <a name="l5267"><span class="ln">5267 </span></a>    <span class="s5">&quot;&quot;&quot;Wrapper for parse actions, to ensure they are only called once. 
5288 <a name="l5268"><span class="ln">5268 </span></a>    &quot;&quot;&quot;</span>
5289 <a name="l5269"><span class="ln">5269 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">methodCall):</span>
5290 <a name="l5270"><span class="ln">5270 </span></a>        <span class="s1">self.callable = _trim_arity(methodCall)</span>
5291 <a name="l5271"><span class="ln">5271 </span></a>        <span class="s1">self.called = </span><span class="s3">False</span>
5292 <a name="l5272"><span class="ln">5272 </span></a>    <span class="s3">def </span><span class="s1">__call__(self</span><span class="s3">, </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5293 <a name="l5273"><span class="ln">5273 </span></a>        <span class="s3">if not </span><span class="s1">self.called:</span>
5294 <a name="l5274"><span class="ln">5274 </span></a>            <span class="s1">results = self.callable(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t)</span>
5295 <a name="l5275"><span class="ln">5275 </span></a>            <span class="s1">self.called = </span><span class="s3">True</span>
5296 <a name="l5276"><span class="ln">5276 </span></a>            <span class="s3">return </span><span class="s1">results</span>
5297 <a name="l5277"><span class="ln">5277 </span></a>        <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;&quot;</span><span class="s1">)</span>
5298 <a name="l5278"><span class="ln">5278 </span></a>    <span class="s3">def </span><span class="s1">reset(self):</span>
5299 <a name="l5279"><span class="ln">5279 </span></a>        <span class="s1">self.called = </span><span class="s3">False</span>
5300 <a name="l5280"><span class="ln">5280 </span></a>
5301 <a name="l5281"><span class="ln">5281 </span></a><span class="s3">def </span><span class="s1">traceParseAction(f):</span>
5302 <a name="l5282"><span class="ln">5282 </span></a>    <span class="s5">&quot;&quot;&quot;Decorator for debugging parse actions. 
5303 <a name="l5283"><span class="ln">5283 </span></a> 
5304 <a name="l5284"><span class="ln">5284 </span></a>    When the parse action is called, this decorator will print 
5305 <a name="l5285"><span class="ln">5285 </span></a>    ``&quot;&gt;&gt; entering method-name(line:&lt;current_source_line&gt;, &lt;parse_location&gt;, &lt;matched_tokens&gt;)&quot;``. 
5306 <a name="l5286"><span class="ln">5286 </span></a>    When the parse action completes, the decorator will print 
5307 <a name="l5287"><span class="ln">5287 </span></a>    ``&quot;&lt;&lt;&quot;`` followed by the returned value, or any exception that the parse action raised. 
5308 <a name="l5288"><span class="ln">5288 </span></a> 
5309 <a name="l5289"><span class="ln">5289 </span></a>    Example:: 
5310 <a name="l5290"><span class="ln">5290 </span></a> 
5311 <a name="l5291"><span class="ln">5291 </span></a>        wd = Word(alphas) 
5312 <a name="l5292"><span class="ln">5292 </span></a> 
5313 <a name="l5293"><span class="ln">5293 </span></a>        @traceParseAction 
5314 <a name="l5294"><span class="ln">5294 </span></a>        def remove_duplicate_chars(tokens): 
5315 <a name="l5295"><span class="ln">5295 </span></a>            return ''.join(sorted(set(''.join(tokens)))) 
5316 <a name="l5296"><span class="ln">5296 </span></a> 
5317 <a name="l5297"><span class="ln">5297 </span></a>        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars) 
5318 <a name="l5298"><span class="ln">5298 </span></a>        print(wds.parseString(&quot;slkdjs sld sldd sdlf sdljf&quot;)) 
5319 <a name="l5299"><span class="ln">5299 </span></a> 
5320 <a name="l5300"><span class="ln">5300 </span></a>    prints:: 
5321 <a name="l5301"><span class="ln">5301 </span></a> 
5322 <a name="l5302"><span class="ln">5302 </span></a>        &gt;&gt;entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {})) 
5323 <a name="l5303"><span class="ln">5303 </span></a>        &lt;&lt;leaving remove_duplicate_chars (ret: 'dfjkls') 
5324 <a name="l5304"><span class="ln">5304 </span></a>        ['dfjkls'] 
5325 <a name="l5305"><span class="ln">5305 </span></a>    &quot;&quot;&quot;</span>
5326 <a name="l5306"><span class="ln">5306 </span></a>    <span class="s1">f = _trim_arity(f)</span>
5327 <a name="l5307"><span class="ln">5307 </span></a>    <span class="s3">def </span><span class="s1">z(*paArgs):</span>
5328 <a name="l5308"><span class="ln">5308 </span></a>        <span class="s1">thisFunc = f.__name__</span>
5329 <a name="l5309"><span class="ln">5309 </span></a>        <span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t = paArgs[-</span><span class="s4">3</span><span class="s1">:]</span>
5330 <a name="l5310"><span class="ln">5310 </span></a>        <span class="s3">if </span><span class="s1">len(paArgs) &gt; </span><span class="s4">3</span><span class="s1">:</span>
5331 <a name="l5311"><span class="ln">5311 </span></a>            <span class="s1">thisFunc = paArgs[</span><span class="s4">0</span><span class="s1">].__class__.__name__ + </span><span class="s2">'.' </span><span class="s1">+ thisFunc</span>
5332 <a name="l5312"><span class="ln">5312 </span></a>        <span class="s1">sys.stderr.write(</span><span class="s2">&quot;&gt;&gt;entering %s(line: '%s', %d, %r)</span><span class="s3">\n</span><span class="s2">&quot; </span><span class="s1">% (thisFunc</span><span class="s3">, </span><span class="s1">line(l</span><span class="s3">, </span><span class="s1">s)</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t))</span>
5333 <a name="l5313"><span class="ln">5313 </span></a>        <span class="s3">try</span><span class="s1">:</span>
5334 <a name="l5314"><span class="ln">5314 </span></a>            <span class="s1">ret = f(*paArgs)</span>
5335 <a name="l5315"><span class="ln">5315 </span></a>        <span class="s3">except </span><span class="s1">Exception </span><span class="s3">as </span><span class="s1">exc:</span>
5336 <a name="l5316"><span class="ln">5316 </span></a>            <span class="s1">sys.stderr.write(</span><span class="s2">&quot;&lt;&lt;leaving %s (exception: %s)</span><span class="s3">\n</span><span class="s2">&quot; </span><span class="s1">% (thisFunc</span><span class="s3">, </span><span class="s1">exc))</span>
5337 <a name="l5317"><span class="ln">5317 </span></a>            <span class="s3">raise</span>
5338 <a name="l5318"><span class="ln">5318 </span></a>        <span class="s1">sys.stderr.write(</span><span class="s2">&quot;&lt;&lt;leaving %s (ret: %r)</span><span class="s3">\n</span><span class="s2">&quot; </span><span class="s1">% (thisFunc</span><span class="s3">, </span><span class="s1">ret))</span>
5339 <a name="l5319"><span class="ln">5319 </span></a>        <span class="s3">return </span><span class="s1">ret</span>
5340 <a name="l5320"><span class="ln">5320 </span></a>    <span class="s3">try</span><span class="s1">:</span>
5341 <a name="l5321"><span class="ln">5321 </span></a>        <span class="s1">z.__name__ = f.__name__</span>
5342 <a name="l5322"><span class="ln">5322 </span></a>    <span class="s3">except </span><span class="s1">AttributeError:</span>
5343 <a name="l5323"><span class="ln">5323 </span></a>        <span class="s3">pass</span>
5344 <a name="l5324"><span class="ln">5324 </span></a>    <span class="s3">return </span><span class="s1">z</span>
5345 <a name="l5325"><span class="ln">5325 </span></a>
5346 <a name="l5326"><span class="ln">5326 </span></a><span class="s0">#</span>
5347 <a name="l5327"><span class="ln">5327 </span></a><span class="s0"># global helpers</span>
5348 <a name="l5328"><span class="ln">5328 </span></a><span class="s0">#</span>
5349 <a name="l5329"><span class="ln">5329 </span></a><span class="s3">def </span><span class="s1">delimitedList(expr</span><span class="s3">, </span><span class="s1">delim=</span><span class="s2">&quot;,&quot;</span><span class="s3">, </span><span class="s1">combine=</span><span class="s3">False</span><span class="s1">):</span>
5350 <a name="l5330"><span class="ln">5330 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to define a delimited list of expressions - the delimiter 
5351 <a name="l5331"><span class="ln">5331 </span></a>    defaults to ','. By default, the list elements and delimiters can 
5352 <a name="l5332"><span class="ln">5332 </span></a>    have intervening whitespace, and comments, but this can be 
5353 <a name="l5333"><span class="ln">5333 </span></a>    overridden by passing ``combine=True`` in the constructor. If 
5354 <a name="l5334"><span class="ln">5334 </span></a>    ``combine`` is set to ``True``, the matching tokens are 
5355 <a name="l5335"><span class="ln">5335 </span></a>    returned as a single token string, with the delimiters included; 
5356 <a name="l5336"><span class="ln">5336 </span></a>    otherwise, the matching tokens are returned as a list of tokens, 
5357 <a name="l5337"><span class="ln">5337 </span></a>    with the delimiters suppressed. 
5358 <a name="l5338"><span class="ln">5338 </span></a> 
5359 <a name="l5339"><span class="ln">5339 </span></a>    Example:: 
5360 <a name="l5340"><span class="ln">5340 </span></a> 
5361 <a name="l5341"><span class="ln">5341 </span></a>        delimitedList(Word(alphas)).parseString(&quot;aa,bb,cc&quot;) # -&gt; ['aa', 'bb', 'cc'] 
5362 <a name="l5342"><span class="ln">5342 </span></a>        delimitedList(Word(hexnums), delim=':', combine=True).parseString(&quot;AA:BB:CC:DD:EE&quot;) # -&gt; ['AA:BB:CC:DD:EE'] 
5363 <a name="l5343"><span class="ln">5343 </span></a>    &quot;&quot;&quot;</span>
5364 <a name="l5344"><span class="ln">5344 </span></a>    <span class="s1">dlName = _ustr(expr) + </span><span class="s2">&quot; [&quot; </span><span class="s1">+ _ustr(delim) + </span><span class="s2">&quot; &quot; </span><span class="s1">+ _ustr(expr) + </span><span class="s2">&quot;]...&quot;</span>
5365 <a name="l5345"><span class="ln">5345 </span></a>    <span class="s3">if </span><span class="s1">combine:</span>
5366 <a name="l5346"><span class="ln">5346 </span></a>        <span class="s3">return </span><span class="s1">Combine(expr + ZeroOrMore(delim + expr)).setName(dlName)</span>
5367 <a name="l5347"><span class="ln">5347 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5368 <a name="l5348"><span class="ln">5348 </span></a>        <span class="s3">return </span><span class="s1">(expr + ZeroOrMore(Suppress(delim) + expr)).setName(dlName)</span>
5369 <a name="l5349"><span class="ln">5349 </span></a>
5370 <a name="l5350"><span class="ln">5350 </span></a><span class="s3">def </span><span class="s1">countedArray(expr</span><span class="s3">, </span><span class="s1">intExpr=</span><span class="s3">None</span><span class="s1">):</span>
5371 <a name="l5351"><span class="ln">5351 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to define a counted list of expressions. 
5372 <a name="l5352"><span class="ln">5352 </span></a> 
5373 <a name="l5353"><span class="ln">5353 </span></a>    This helper defines a pattern of the form:: 
5374 <a name="l5354"><span class="ln">5354 </span></a> 
5375 <a name="l5355"><span class="ln">5355 </span></a>        integer expr expr expr... 
5376 <a name="l5356"><span class="ln">5356 </span></a> 
5377 <a name="l5357"><span class="ln">5357 </span></a>    where the leading integer tells how many expr expressions follow. 
5378 <a name="l5358"><span class="ln">5358 </span></a>    The matched tokens returns the array of expr tokens as a list - the 
5379 <a name="l5359"><span class="ln">5359 </span></a>    leading count token is suppressed. 
5380 <a name="l5360"><span class="ln">5360 </span></a> 
5381 <a name="l5361"><span class="ln">5361 </span></a>    If ``intExpr`` is specified, it should be a pyparsing expression 
5382 <a name="l5362"><span class="ln">5362 </span></a>    that produces an integer value. 
5383 <a name="l5363"><span class="ln">5363 </span></a> 
5384 <a name="l5364"><span class="ln">5364 </span></a>    Example:: 
5385 <a name="l5365"><span class="ln">5365 </span></a> 
5386 <a name="l5366"><span class="ln">5366 </span></a>        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -&gt; ['ab', 'cd'] 
5387 <a name="l5367"><span class="ln">5367 </span></a> 
5388 <a name="l5368"><span class="ln">5368 </span></a>        # in this parser, the leading integer value is given in binary, 
5389 <a name="l5369"><span class="ln">5369 </span></a>        # '10' indicating that 2 values are in the array 
5390 <a name="l5370"><span class="ln">5370 </span></a>        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2)) 
5391 <a name="l5371"><span class="ln">5371 </span></a>        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -&gt; ['ab', 'cd'] 
5392 <a name="l5372"><span class="ln">5372 </span></a>    &quot;&quot;&quot;</span>
5393 <a name="l5373"><span class="ln">5373 </span></a>    <span class="s1">arrayExpr = Forward()</span>
5394 <a name="l5374"><span class="ln">5374 </span></a>    <span class="s3">def </span><span class="s1">countFieldParseAction(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5395 <a name="l5375"><span class="ln">5375 </span></a>        <span class="s1">n = t[</span><span class="s4">0</span><span class="s1">]</span>
5396 <a name="l5376"><span class="ln">5376 </span></a>        <span class="s1">arrayExpr &lt;&lt; (n </span><span class="s3">and </span><span class="s1">Group(And([expr] * n)) </span><span class="s3">or </span><span class="s1">Group(empty))</span>
5397 <a name="l5377"><span class="ln">5377 </span></a>        <span class="s3">return </span><span class="s1">[]</span>
5398 <a name="l5378"><span class="ln">5378 </span></a>    <span class="s3">if </span><span class="s1">intExpr </span><span class="s3">is None</span><span class="s1">:</span>
5399 <a name="l5379"><span class="ln">5379 </span></a>        <span class="s1">intExpr = Word(nums).setParseAction(</span><span class="s3">lambda </span><span class="s1">t: int(t[</span><span class="s4">0</span><span class="s1">]))</span>
5400 <a name="l5380"><span class="ln">5380 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5401 <a name="l5381"><span class="ln">5381 </span></a>        <span class="s1">intExpr = intExpr.copy()</span>
5402 <a name="l5382"><span class="ln">5382 </span></a>    <span class="s1">intExpr.setName(</span><span class="s2">&quot;arrayLen&quot;</span><span class="s1">)</span>
5403 <a name="l5383"><span class="ln">5383 </span></a>    <span class="s1">intExpr.addParseAction(countFieldParseAction</span><span class="s3">, </span><span class="s1">callDuringTry=</span><span class="s3">True</span><span class="s1">)</span>
5404 <a name="l5384"><span class="ln">5384 </span></a>    <span class="s3">return </span><span class="s1">(intExpr + arrayExpr).setName(</span><span class="s2">'(len) ' </span><span class="s1">+ _ustr(expr) + </span><span class="s2">'...'</span><span class="s1">)</span>
5405 <a name="l5385"><span class="ln">5385 </span></a>
5406 <a name="l5386"><span class="ln">5386 </span></a><span class="s3">def </span><span class="s1">_flatten(L):</span>
5407 <a name="l5387"><span class="ln">5387 </span></a>    <span class="s1">ret = []</span>
5408 <a name="l5388"><span class="ln">5388 </span></a>    <span class="s3">for </span><span class="s1">i </span><span class="s3">in </span><span class="s1">L:</span>
5409 <a name="l5389"><span class="ln">5389 </span></a>        <span class="s3">if </span><span class="s1">isinstance(i</span><span class="s3">, </span><span class="s1">list):</span>
5410 <a name="l5390"><span class="ln">5390 </span></a>            <span class="s1">ret.extend(_flatten(i))</span>
5411 <a name="l5391"><span class="ln">5391 </span></a>        <span class="s3">else</span><span class="s1">:</span>
5412 <a name="l5392"><span class="ln">5392 </span></a>            <span class="s1">ret.append(i)</span>
5413 <a name="l5393"><span class="ln">5393 </span></a>    <span class="s3">return </span><span class="s1">ret</span>
5414 <a name="l5394"><span class="ln">5394 </span></a>
5415 <a name="l5395"><span class="ln">5395 </span></a><span class="s3">def </span><span class="s1">matchPreviousLiteral(expr):</span>
5416 <a name="l5396"><span class="ln">5396 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to define an expression that is indirectly defined from 
5417 <a name="l5397"><span class="ln">5397 </span></a>    the tokens matched in a previous expression, that is, it looks for 
5418 <a name="l5398"><span class="ln">5398 </span></a>    a 'repeat' of a previous expression.  For example:: 
5419 <a name="l5399"><span class="ln">5399 </span></a> 
5420 <a name="l5400"><span class="ln">5400 </span></a>        first = Word(nums) 
5421 <a name="l5401"><span class="ln">5401 </span></a>        second = matchPreviousLiteral(first) 
5422 <a name="l5402"><span class="ln">5402 </span></a>        matchExpr = first + &quot;:&quot; + second 
5423 <a name="l5403"><span class="ln">5403 </span></a> 
5424 <a name="l5404"><span class="ln">5404 </span></a>    will match ``&quot;1:1&quot;``, but not ``&quot;1:2&quot;``.  Because this 
5425 <a name="l5405"><span class="ln">5405 </span></a>    matches a previous literal, will also match the leading 
5426 <a name="l5406"><span class="ln">5406 </span></a>    ``&quot;1:1&quot;`` in ``&quot;1:10&quot;``. If this is not desired, use 
5427 <a name="l5407"><span class="ln">5407 </span></a>    :class:`matchPreviousExpr`. Do *not* use with packrat parsing 
5428 <a name="l5408"><span class="ln">5408 </span></a>    enabled. 
5429 <a name="l5409"><span class="ln">5409 </span></a>    &quot;&quot;&quot;</span>
5430 <a name="l5410"><span class="ln">5410 </span></a>    <span class="s1">rep = Forward()</span>
5431 <a name="l5411"><span class="ln">5411 </span></a>    <span class="s3">def </span><span class="s1">copyTokenToRepeater(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5432 <a name="l5412"><span class="ln">5412 </span></a>        <span class="s3">if </span><span class="s1">t:</span>
5433 <a name="l5413"><span class="ln">5413 </span></a>            <span class="s3">if </span><span class="s1">len(t) == </span><span class="s4">1</span><span class="s1">:</span>
5434 <a name="l5414"><span class="ln">5414 </span></a>                <span class="s1">rep &lt;&lt; t[</span><span class="s4">0</span><span class="s1">]</span>
5435 <a name="l5415"><span class="ln">5415 </span></a>            <span class="s3">else</span><span class="s1">:</span>
5436 <a name="l5416"><span class="ln">5416 </span></a>                <span class="s0"># flatten t tokens</span>
5437 <a name="l5417"><span class="ln">5417 </span></a>                <span class="s1">tflat = _flatten(t.asList())</span>
5438 <a name="l5418"><span class="ln">5418 </span></a>                <span class="s1">rep &lt;&lt; And(Literal(tt) </span><span class="s3">for </span><span class="s1">tt </span><span class="s3">in </span><span class="s1">tflat)</span>
5439 <a name="l5419"><span class="ln">5419 </span></a>        <span class="s3">else</span><span class="s1">:</span>
5440 <a name="l5420"><span class="ln">5420 </span></a>            <span class="s1">rep &lt;&lt; Empty()</span>
5441 <a name="l5421"><span class="ln">5421 </span></a>    <span class="s1">expr.addParseAction(copyTokenToRepeater</span><span class="s3">, </span><span class="s1">callDuringTry=</span><span class="s3">True</span><span class="s1">)</span>
5442 <a name="l5422"><span class="ln">5422 </span></a>    <span class="s1">rep.setName(</span><span class="s2">'(prev) ' </span><span class="s1">+ _ustr(expr))</span>
5443 <a name="l5423"><span class="ln">5423 </span></a>    <span class="s3">return </span><span class="s1">rep</span>
5444 <a name="l5424"><span class="ln">5424 </span></a>
5445 <a name="l5425"><span class="ln">5425 </span></a><span class="s3">def </span><span class="s1">matchPreviousExpr(expr):</span>
5446 <a name="l5426"><span class="ln">5426 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to define an expression that is indirectly defined from 
5447 <a name="l5427"><span class="ln">5427 </span></a>    the tokens matched in a previous expression, that is, it looks for 
5448 <a name="l5428"><span class="ln">5428 </span></a>    a 'repeat' of a previous expression.  For example:: 
5449 <a name="l5429"><span class="ln">5429 </span></a> 
5450 <a name="l5430"><span class="ln">5430 </span></a>        first = Word(nums) 
5451 <a name="l5431"><span class="ln">5431 </span></a>        second = matchPreviousExpr(first) 
5452 <a name="l5432"><span class="ln">5432 </span></a>        matchExpr = first + &quot;:&quot; + second 
5453 <a name="l5433"><span class="ln">5433 </span></a> 
5454 <a name="l5434"><span class="ln">5434 </span></a>    will match ``&quot;1:1&quot;``, but not ``&quot;1:2&quot;``.  Because this 
5455 <a name="l5435"><span class="ln">5435 </span></a>    matches by expressions, will *not* match the leading ``&quot;1:1&quot;`` 
5456 <a name="l5436"><span class="ln">5436 </span></a>    in ``&quot;1:10&quot;``; the expressions are evaluated first, and then 
5457 <a name="l5437"><span class="ln">5437 </span></a>    compared, so ``&quot;1&quot;`` is compared with ``&quot;10&quot;``. Do *not* use 
5458 <a name="l5438"><span class="ln">5438 </span></a>    with packrat parsing enabled. 
5459 <a name="l5439"><span class="ln">5439 </span></a>    &quot;&quot;&quot;</span>
5460 <a name="l5440"><span class="ln">5440 </span></a>    <span class="s1">rep = Forward()</span>
5461 <a name="l5441"><span class="ln">5441 </span></a>    <span class="s1">e2 = expr.copy()</span>
5462 <a name="l5442"><span class="ln">5442 </span></a>    <span class="s1">rep &lt;&lt;= e2</span>
5463 <a name="l5443"><span class="ln">5443 </span></a>    <span class="s3">def </span><span class="s1">copyTokenToRepeater(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5464 <a name="l5444"><span class="ln">5444 </span></a>        <span class="s1">matchTokens = _flatten(t.asList())</span>
5465 <a name="l5445"><span class="ln">5445 </span></a>        <span class="s3">def </span><span class="s1">mustMatchTheseTokens(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5466 <a name="l5446"><span class="ln">5446 </span></a>            <span class="s1">theseTokens = _flatten(t.asList())</span>
5467 <a name="l5447"><span class="ln">5447 </span></a>            <span class="s3">if </span><span class="s1">theseTokens != matchTokens:</span>
5468 <a name="l5448"><span class="ln">5448 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(</span><span class="s2">''</span><span class="s3">, </span><span class="s4">0</span><span class="s3">, </span><span class="s2">''</span><span class="s1">)</span>
5469 <a name="l5449"><span class="ln">5449 </span></a>        <span class="s1">rep.setParseAction(mustMatchTheseTokens</span><span class="s3">, </span><span class="s1">callDuringTry=</span><span class="s3">True</span><span class="s1">)</span>
5470 <a name="l5450"><span class="ln">5450 </span></a>    <span class="s1">expr.addParseAction(copyTokenToRepeater</span><span class="s3">, </span><span class="s1">callDuringTry=</span><span class="s3">True</span><span class="s1">)</span>
5471 <a name="l5451"><span class="ln">5451 </span></a>    <span class="s1">rep.setName(</span><span class="s2">'(prev) ' </span><span class="s1">+ _ustr(expr))</span>
5472 <a name="l5452"><span class="ln">5452 </span></a>    <span class="s3">return </span><span class="s1">rep</span>
5473 <a name="l5453"><span class="ln">5453 </span></a>
5474 <a name="l5454"><span class="ln">5454 </span></a><span class="s3">def </span><span class="s1">_escapeRegexRangeChars(s):</span>
5475 <a name="l5455"><span class="ln">5455 </span></a>    <span class="s0"># ~  escape these chars: ^-[]</span>
5476 <a name="l5456"><span class="ln">5456 </span></a>    <span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s2">r&quot;\^-[]&quot;</span><span class="s1">:</span>
5477 <a name="l5457"><span class="ln">5457 </span></a>        <span class="s1">s = s.replace(c</span><span class="s3">, </span><span class="s1">_bslash + c)</span>
5478 <a name="l5458"><span class="ln">5458 </span></a>    <span class="s1">s = s.replace(</span><span class="s2">&quot;</span><span class="s3">\n</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s2">r&quot;\n&quot;</span><span class="s1">)</span>
5479 <a name="l5459"><span class="ln">5459 </span></a>    <span class="s1">s = s.replace(</span><span class="s2">&quot;</span><span class="s3">\t</span><span class="s2">&quot;</span><span class="s3">, </span><span class="s2">r&quot;\t&quot;</span><span class="s1">)</span>
5480 <a name="l5460"><span class="ln">5460 </span></a>    <span class="s3">return </span><span class="s1">_ustr(s)</span>
5481 <a name="l5461"><span class="ln">5461 </span></a>
5482 <a name="l5462"><span class="ln">5462 </span></a><span class="s3">def </span><span class="s1">oneOf(strs</span><span class="s3">, </span><span class="s1">caseless=</span><span class="s3">False, </span><span class="s1">useRegex=</span><span class="s3">True, </span><span class="s1">asKeyword=</span><span class="s3">False</span><span class="s1">):</span>
5483 <a name="l5463"><span class="ln">5463 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to quickly define a set of alternative Literals, and makes 
5484 <a name="l5464"><span class="ln">5464 </span></a>    sure to do longest-first testing when there is a conflict, 
5485 <a name="l5465"><span class="ln">5465 </span></a>    regardless of the input order, but returns 
5486 <a name="l5466"><span class="ln">5466 </span></a>    a :class:`MatchFirst` for best performance. 
5487 <a name="l5467"><span class="ln">5467 </span></a> 
5488 <a name="l5468"><span class="ln">5468 </span></a>    Parameters: 
5489 <a name="l5469"><span class="ln">5469 </span></a> 
5490 <a name="l5470"><span class="ln">5470 </span></a>     - strs - a string of space-delimited literals, or a collection of 
5491 <a name="l5471"><span class="ln">5471 </span></a>       string literals 
5492 <a name="l5472"><span class="ln">5472 </span></a>     - caseless - (default= ``False``) - treat all literals as 
5493 <a name="l5473"><span class="ln">5473 </span></a>       caseless 
5494 <a name="l5474"><span class="ln">5474 </span></a>     - useRegex - (default= ``True``) - as an optimization, will 
5495 <a name="l5475"><span class="ln">5475 </span></a>       generate a Regex object; otherwise, will generate 
5496 <a name="l5476"><span class="ln">5476 </span></a>       a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if 
5497 <a name="l5477"><span class="ln">5477 </span></a>       creating a :class:`Regex` raises an exception) 
5498 <a name="l5478"><span class="ln">5478 </span></a>     - asKeyword - (default=``False``) - enforce Keyword-style matching on the 
5499 <a name="l5479"><span class="ln">5479 </span></a>       generated expressions 
5500 <a name="l5480"><span class="ln">5480 </span></a> 
5501 <a name="l5481"><span class="ln">5481 </span></a>    Example:: 
5502 <a name="l5482"><span class="ln">5482 </span></a> 
5503 <a name="l5483"><span class="ln">5483 </span></a>        comp_oper = oneOf(&quot;&lt; = &gt; &lt;= &gt;= !=&quot;) 
5504 <a name="l5484"><span class="ln">5484 </span></a>        var = Word(alphas) 
5505 <a name="l5485"><span class="ln">5485 </span></a>        number = Word(nums) 
5506 <a name="l5486"><span class="ln">5486 </span></a>        term = var | number 
5507 <a name="l5487"><span class="ln">5487 </span></a>        comparison_expr = term + comp_oper + term 
5508 <a name="l5488"><span class="ln">5488 </span></a>        print(comparison_expr.searchString(&quot;B = 12  AA=23 B&lt;=AA AA&gt;12&quot;)) 
5509 <a name="l5489"><span class="ln">5489 </span></a> 
5510 <a name="l5490"><span class="ln">5490 </span></a>    prints:: 
5511 <a name="l5491"><span class="ln">5491 </span></a> 
5512 <a name="l5492"><span class="ln">5492 </span></a>        [['B', '=', '12'], ['AA', '=', '23'], ['B', '&lt;=', 'AA'], ['AA', '&gt;', '12']] 
5513 <a name="l5493"><span class="ln">5493 </span></a>    &quot;&quot;&quot;</span>
5514 <a name="l5494"><span class="ln">5494 </span></a>    <span class="s3">if </span><span class="s1">isinstance(caseless</span><span class="s3">, </span><span class="s1">basestring):</span>
5515 <a name="l5495"><span class="ln">5495 </span></a>        <span class="s1">warnings.warn(</span><span class="s2">&quot;More than one string argument passed to oneOf, pass &quot;</span>
5516 <a name="l5496"><span class="ln">5496 </span></a>                      <span class="s2">&quot;choices as a list or space-delimited string&quot;</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
5517 <a name="l5497"><span class="ln">5497 </span></a>
5518 <a name="l5498"><span class="ln">5498 </span></a>    <span class="s3">if </span><span class="s1">caseless:</span>
5519 <a name="l5499"><span class="ln">5499 </span></a>        <span class="s1">isequal = (</span><span class="s3">lambda </span><span class="s1">a</span><span class="s3">, </span><span class="s1">b: a.upper() == b.upper())</span>
5520 <a name="l5500"><span class="ln">5500 </span></a>        <span class="s1">masks = (</span><span class="s3">lambda </span><span class="s1">a</span><span class="s3">, </span><span class="s1">b: b.upper().startswith(a.upper()))</span>
5521 <a name="l5501"><span class="ln">5501 </span></a>        <span class="s1">parseElementClass = CaselessKeyword </span><span class="s3">if </span><span class="s1">asKeyword </span><span class="s3">else </span><span class="s1">CaselessLiteral</span>
5522 <a name="l5502"><span class="ln">5502 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5523 <a name="l5503"><span class="ln">5503 </span></a>        <span class="s1">isequal = (</span><span class="s3">lambda </span><span class="s1">a</span><span class="s3">, </span><span class="s1">b: a == b)</span>
5524 <a name="l5504"><span class="ln">5504 </span></a>        <span class="s1">masks = (</span><span class="s3">lambda </span><span class="s1">a</span><span class="s3">, </span><span class="s1">b: b.startswith(a))</span>
5525 <a name="l5505"><span class="ln">5505 </span></a>        <span class="s1">parseElementClass = Keyword </span><span class="s3">if </span><span class="s1">asKeyword </span><span class="s3">else </span><span class="s1">Literal</span>
5526 <a name="l5506"><span class="ln">5506 </span></a>
5527 <a name="l5507"><span class="ln">5507 </span></a>    <span class="s1">symbols = []</span>
5528 <a name="l5508"><span class="ln">5508 </span></a>    <span class="s3">if </span><span class="s1">isinstance(strs</span><span class="s3">, </span><span class="s1">basestring):</span>
5529 <a name="l5509"><span class="ln">5509 </span></a>        <span class="s1">symbols = strs.split()</span>
5530 <a name="l5510"><span class="ln">5510 </span></a>    <span class="s3">elif </span><span class="s1">isinstance(strs</span><span class="s3">, </span><span class="s1">Iterable):</span>
5531 <a name="l5511"><span class="ln">5511 </span></a>        <span class="s1">symbols = list(strs)</span>
5532 <a name="l5512"><span class="ln">5512 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5533 <a name="l5513"><span class="ln">5513 </span></a>        <span class="s1">warnings.warn(</span><span class="s2">&quot;Invalid argument to oneOf, expected string or iterable&quot;</span><span class="s3">,</span>
5534 <a name="l5514"><span class="ln">5514 </span></a>                      <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
5535 <a name="l5515"><span class="ln">5515 </span></a>    <span class="s3">if not </span><span class="s1">symbols:</span>
5536 <a name="l5516"><span class="ln">5516 </span></a>        <span class="s3">return </span><span class="s1">NoMatch()</span>
5537 <a name="l5517"><span class="ln">5517 </span></a>
5538 <a name="l5518"><span class="ln">5518 </span></a>    <span class="s3">if not </span><span class="s1">asKeyword:</span>
5539 <a name="l5519"><span class="ln">5519 </span></a>        <span class="s0"># if not producing keywords, need to reorder to take care to avoid masking</span>
5540 <a name="l5520"><span class="ln">5520 </span></a>        <span class="s0"># longer choices with shorter ones</span>
5541 <a name="l5521"><span class="ln">5521 </span></a>        <span class="s1">i = </span><span class="s4">0</span>
5542 <a name="l5522"><span class="ln">5522 </span></a>        <span class="s3">while </span><span class="s1">i &lt; len(symbols) - </span><span class="s4">1</span><span class="s1">:</span>
5543 <a name="l5523"><span class="ln">5523 </span></a>            <span class="s1">cur = symbols[i]</span>
5544 <a name="l5524"><span class="ln">5524 </span></a>            <span class="s3">for </span><span class="s1">j</span><span class="s3">, </span><span class="s1">other </span><span class="s3">in </span><span class="s1">enumerate(symbols[i + </span><span class="s4">1</span><span class="s1">:]):</span>
5545 <a name="l5525"><span class="ln">5525 </span></a>                <span class="s3">if </span><span class="s1">isequal(other</span><span class="s3">, </span><span class="s1">cur):</span>
5546 <a name="l5526"><span class="ln">5526 </span></a>                    <span class="s3">del </span><span class="s1">symbols[i + j + </span><span class="s4">1</span><span class="s1">]</span>
5547 <a name="l5527"><span class="ln">5527 </span></a>                    <span class="s3">break</span>
5548 <a name="l5528"><span class="ln">5528 </span></a>                <span class="s3">elif </span><span class="s1">masks(cur</span><span class="s3">, </span><span class="s1">other):</span>
5549 <a name="l5529"><span class="ln">5529 </span></a>                    <span class="s3">del </span><span class="s1">symbols[i + j + </span><span class="s4">1</span><span class="s1">]</span>
5550 <a name="l5530"><span class="ln">5530 </span></a>                    <span class="s1">symbols.insert(i</span><span class="s3">, </span><span class="s1">other)</span>
5551 <a name="l5531"><span class="ln">5531 </span></a>                    <span class="s3">break</span>
5552 <a name="l5532"><span class="ln">5532 </span></a>            <span class="s3">else</span><span class="s1">:</span>
5553 <a name="l5533"><span class="ln">5533 </span></a>                <span class="s1">i += </span><span class="s4">1</span>
5554 <a name="l5534"><span class="ln">5534 </span></a>
5555 <a name="l5535"><span class="ln">5535 </span></a>    <span class="s3">if not </span><span class="s1">(caseless </span><span class="s3">or </span><span class="s1">asKeyword) </span><span class="s3">and </span><span class="s1">useRegex:</span>
5556 <a name="l5536"><span class="ln">5536 </span></a>        <span class="s0"># ~ print (strs, &quot;-&gt;&quot;, &quot;|&quot;.join([_escapeRegexChars(sym) for sym in symbols]))</span>
5557 <a name="l5537"><span class="ln">5537 </span></a>        <span class="s3">try</span><span class="s1">:</span>
5558 <a name="l5538"><span class="ln">5538 </span></a>            <span class="s3">if </span><span class="s1">len(symbols) == len(</span><span class="s2">&quot;&quot;</span><span class="s1">.join(symbols)):</span>
5559 <a name="l5539"><span class="ln">5539 </span></a>                <span class="s3">return </span><span class="s1">Regex(</span><span class="s2">&quot;[%s]&quot; </span><span class="s1">% </span><span class="s2">&quot;&quot;</span><span class="s1">.join(_escapeRegexRangeChars(sym) </span><span class="s3">for </span><span class="s1">sym </span><span class="s3">in </span><span class="s1">symbols)).setName(</span><span class="s2">' | '</span><span class="s1">.join(symbols))</span>
5560 <a name="l5540"><span class="ln">5540 </span></a>            <span class="s3">else</span><span class="s1">:</span>
5561 <a name="l5541"><span class="ln">5541 </span></a>                <span class="s3">return </span><span class="s1">Regex(</span><span class="s2">&quot;|&quot;</span><span class="s1">.join(re.escape(sym) </span><span class="s3">for </span><span class="s1">sym </span><span class="s3">in </span><span class="s1">symbols)).setName(</span><span class="s2">' | '</span><span class="s1">.join(symbols))</span>
5562 <a name="l5542"><span class="ln">5542 </span></a>        <span class="s3">except </span><span class="s1">Exception:</span>
5563 <a name="l5543"><span class="ln">5543 </span></a>            <span class="s1">warnings.warn(</span><span class="s2">&quot;Exception creating Regex for oneOf, building MatchFirst&quot;</span><span class="s3">,</span>
5564 <a name="l5544"><span class="ln">5544 </span></a>                    <span class="s1">SyntaxWarning</span><span class="s3">, </span><span class="s1">stacklevel=</span><span class="s4">2</span><span class="s1">)</span>
5565 <a name="l5545"><span class="ln">5545 </span></a>
5566 <a name="l5546"><span class="ln">5546 </span></a>    <span class="s0"># last resort, just use MatchFirst</span>
5567 <a name="l5547"><span class="ln">5547 </span></a>    <span class="s3">return </span><span class="s1">MatchFirst(parseElementClass(sym) </span><span class="s3">for </span><span class="s1">sym </span><span class="s3">in </span><span class="s1">symbols).setName(</span><span class="s2">' | '</span><span class="s1">.join(symbols))</span>
5568 <a name="l5548"><span class="ln">5548 </span></a>
5569 <a name="l5549"><span class="ln">5549 </span></a><span class="s3">def </span><span class="s1">dictOf(key</span><span class="s3">, </span><span class="s1">value):</span>
5570 <a name="l5550"><span class="ln">5550 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to easily and clearly define a dictionary by specifying 
5571 <a name="l5551"><span class="ln">5551 </span></a>    the respective patterns for the key and value.  Takes care of 
5572 <a name="l5552"><span class="ln">5552 </span></a>    defining the :class:`Dict`, :class:`ZeroOrMore`, and 
5573 <a name="l5553"><span class="ln">5553 </span></a>    :class:`Group` tokens in the proper order.  The key pattern 
5574 <a name="l5554"><span class="ln">5554 </span></a>    can include delimiting markers or punctuation, as long as they are 
5575 <a name="l5555"><span class="ln">5555 </span></a>    suppressed, thereby leaving the significant key text.  The value 
5576 <a name="l5556"><span class="ln">5556 </span></a>    pattern can include named results, so that the :class:`Dict` results 
5577 <a name="l5557"><span class="ln">5557 </span></a>    can include named token fields. 
5578 <a name="l5558"><span class="ln">5558 </span></a> 
5579 <a name="l5559"><span class="ln">5559 </span></a>    Example:: 
5580 <a name="l5560"><span class="ln">5560 </span></a> 
5581 <a name="l5561"><span class="ln">5561 </span></a>        text = &quot;shape: SQUARE posn: upper left color: light blue texture: burlap&quot; 
5582 <a name="l5562"><span class="ln">5562 </span></a>        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
5583 <a name="l5563"><span class="ln">5563 </span></a>        print(OneOrMore(attr_expr).parseString(text).dump()) 
5584 <a name="l5564"><span class="ln">5564 </span></a> 
5585 <a name="l5565"><span class="ln">5565 </span></a>        attr_label = label 
5586 <a name="l5566"><span class="ln">5566 </span></a>        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join) 
5587 <a name="l5567"><span class="ln">5567 </span></a> 
5588 <a name="l5568"><span class="ln">5568 </span></a>        # similar to Dict, but simpler call format 
5589 <a name="l5569"><span class="ln">5569 </span></a>        result = dictOf(attr_label, attr_value).parseString(text) 
5590 <a name="l5570"><span class="ln">5570 </span></a>        print(result.dump()) 
5591 <a name="l5571"><span class="ln">5571 </span></a>        print(result['shape']) 
5592 <a name="l5572"><span class="ln">5572 </span></a>        print(result.shape)  # object attribute access works too 
5593 <a name="l5573"><span class="ln">5573 </span></a>        print(result.asDict()) 
5594 <a name="l5574"><span class="ln">5574 </span></a> 
5595 <a name="l5575"><span class="ln">5575 </span></a>    prints:: 
5596 <a name="l5576"><span class="ln">5576 </span></a> 
5597 <a name="l5577"><span class="ln">5577 </span></a>        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 
5598 <a name="l5578"><span class="ln">5578 </span></a>        - color: light blue 
5599 <a name="l5579"><span class="ln">5579 </span></a>        - posn: upper left 
5600 <a name="l5580"><span class="ln">5580 </span></a>        - shape: SQUARE 
5601 <a name="l5581"><span class="ln">5581 </span></a>        - texture: burlap 
5602 <a name="l5582"><span class="ln">5582 </span></a>        SQUARE 
5603 <a name="l5583"><span class="ln">5583 </span></a>        SQUARE 
5604 <a name="l5584"><span class="ln">5584 </span></a>        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'} 
5605 <a name="l5585"><span class="ln">5585 </span></a>    &quot;&quot;&quot;</span>
5606 <a name="l5586"><span class="ln">5586 </span></a>    <span class="s3">return </span><span class="s1">Dict(OneOrMore(Group(key + value)))</span>
5607 <a name="l5587"><span class="ln">5587 </span></a>
5608 <a name="l5588"><span class="ln">5588 </span></a><span class="s3">def </span><span class="s1">originalTextFor(expr</span><span class="s3">, </span><span class="s1">asString=</span><span class="s3">True</span><span class="s1">):</span>
5609 <a name="l5589"><span class="ln">5589 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to return the original, untokenized text for a given 
5610 <a name="l5590"><span class="ln">5590 </span></a>    expression.  Useful to restore the parsed fields of an HTML start 
5611 <a name="l5591"><span class="ln">5591 </span></a>    tag into the raw tag text itself, or to revert separate tokens with 
5612 <a name="l5592"><span class="ln">5592 </span></a>    intervening whitespace back to the original matching input text. By 
5613 <a name="l5593"><span class="ln">5593 </span></a>    default, returns astring containing the original parsed text. 
5614 <a name="l5594"><span class="ln">5594 </span></a> 
5615 <a name="l5595"><span class="ln">5595 </span></a>    If the optional ``asString`` argument is passed as 
5616 <a name="l5596"><span class="ln">5596 </span></a>    ``False``, then the return value is 
5617 <a name="l5597"><span class="ln">5597 </span></a>    a :class:`ParseResults` containing any results names that 
5618 <a name="l5598"><span class="ln">5598 </span></a>    were originally matched, and a single token containing the original 
5619 <a name="l5599"><span class="ln">5599 </span></a>    matched text from the input string.  So if the expression passed to 
5620 <a name="l5600"><span class="ln">5600 </span></a>    :class:`originalTextFor` contains expressions with defined 
5621 <a name="l5601"><span class="ln">5601 </span></a>    results names, you must set ``asString`` to ``False`` if you 
5622 <a name="l5602"><span class="ln">5602 </span></a>    want to preserve those results name values. 
5623 <a name="l5603"><span class="ln">5603 </span></a> 
5624 <a name="l5604"><span class="ln">5604 </span></a>    Example:: 
5625 <a name="l5605"><span class="ln">5605 </span></a> 
5626 <a name="l5606"><span class="ln">5606 </span></a>        src = &quot;this is test &lt;b&gt; bold &lt;i&gt;text&lt;/i&gt; &lt;/b&gt; normal text &quot; 
5627 <a name="l5607"><span class="ln">5607 </span></a>        for tag in (&quot;b&quot;, &quot;i&quot;): 
5628 <a name="l5608"><span class="ln">5608 </span></a>            opener, closer = makeHTMLTags(tag) 
5629 <a name="l5609"><span class="ln">5609 </span></a>            patt = originalTextFor(opener + SkipTo(closer) + closer) 
5630 <a name="l5610"><span class="ln">5610 </span></a>            print(patt.searchString(src)[0]) 
5631 <a name="l5611"><span class="ln">5611 </span></a> 
5632 <a name="l5612"><span class="ln">5612 </span></a>    prints:: 
5633 <a name="l5613"><span class="ln">5613 </span></a> 
5634 <a name="l5614"><span class="ln">5614 </span></a>        ['&lt;b&gt; bold &lt;i&gt;text&lt;/i&gt; &lt;/b&gt;'] 
5635 <a name="l5615"><span class="ln">5615 </span></a>        ['&lt;i&gt;text&lt;/i&gt;'] 
5636 <a name="l5616"><span class="ln">5616 </span></a>    &quot;&quot;&quot;</span>
5637 <a name="l5617"><span class="ln">5617 </span></a>    <span class="s1">locMarker = Empty().setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">t: loc)</span>
5638 <a name="l5618"><span class="ln">5618 </span></a>    <span class="s1">endlocMarker = locMarker.copy()</span>
5639 <a name="l5619"><span class="ln">5619 </span></a>    <span class="s1">endlocMarker.callPreparse = </span><span class="s3">False</span>
5640 <a name="l5620"><span class="ln">5620 </span></a>    <span class="s1">matchExpr = locMarker(</span><span class="s2">&quot;_original_start&quot;</span><span class="s1">) + expr + endlocMarker(</span><span class="s2">&quot;_original_end&quot;</span><span class="s1">)</span>
5641 <a name="l5621"><span class="ln">5621 </span></a>    <span class="s3">if </span><span class="s1">asString:</span>
5642 <a name="l5622"><span class="ln">5622 </span></a>        <span class="s1">extractText = </span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: s[t._original_start: t._original_end]</span>
5643 <a name="l5623"><span class="ln">5623 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5644 <a name="l5624"><span class="ln">5624 </span></a>        <span class="s3">def </span><span class="s1">extractText(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5645 <a name="l5625"><span class="ln">5625 </span></a>            <span class="s1">t[:] = [s[t.pop(</span><span class="s2">'_original_start'</span><span class="s1">):t.pop(</span><span class="s2">'_original_end'</span><span class="s1">)]]</span>
5646 <a name="l5626"><span class="ln">5626 </span></a>    <span class="s1">matchExpr.setParseAction(extractText)</span>
5647 <a name="l5627"><span class="ln">5627 </span></a>    <span class="s1">matchExpr.ignoreExprs = expr.ignoreExprs</span>
5648 <a name="l5628"><span class="ln">5628 </span></a>    <span class="s3">return </span><span class="s1">matchExpr</span>
5649 <a name="l5629"><span class="ln">5629 </span></a>
5650 <a name="l5630"><span class="ln">5630 </span></a><span class="s3">def </span><span class="s1">ungroup(expr):</span>
5651 <a name="l5631"><span class="ln">5631 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to undo pyparsing's default grouping of And expressions, 
5652 <a name="l5632"><span class="ln">5632 </span></a>    even if all but one are non-empty. 
5653 <a name="l5633"><span class="ln">5633 </span></a>    &quot;&quot;&quot;</span>
5654 <a name="l5634"><span class="ln">5634 </span></a>    <span class="s3">return </span><span class="s1">TokenConverter(expr).addParseAction(</span><span class="s3">lambda </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">])</span>
5655 <a name="l5635"><span class="ln">5635 </span></a>
5656 <a name="l5636"><span class="ln">5636 </span></a><span class="s3">def </span><span class="s1">locatedExpr(expr):</span>
5657 <a name="l5637"><span class="ln">5637 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to decorate a returned token with its starting and ending 
5658 <a name="l5638"><span class="ln">5638 </span></a>    locations in the input string. 
5659 <a name="l5639"><span class="ln">5639 </span></a> 
5660 <a name="l5640"><span class="ln">5640 </span></a>    This helper adds the following results names: 
5661 <a name="l5641"><span class="ln">5641 </span></a> 
5662 <a name="l5642"><span class="ln">5642 </span></a>     - locn_start = location where matched expression begins 
5663 <a name="l5643"><span class="ln">5643 </span></a>     - locn_end = location where matched expression ends 
5664 <a name="l5644"><span class="ln">5644 </span></a>     - value = the actual parsed results 
5665 <a name="l5645"><span class="ln">5645 </span></a> 
5666 <a name="l5646"><span class="ln">5646 </span></a>    Be careful if the input text contains ``&lt;TAB&gt;`` characters, you 
5667 <a name="l5647"><span class="ln">5647 </span></a>    may want to call :class:`ParserElement.parseWithTabs` 
5668 <a name="l5648"><span class="ln">5648 </span></a> 
5669 <a name="l5649"><span class="ln">5649 </span></a>    Example:: 
5670 <a name="l5650"><span class="ln">5650 </span></a> 
5671 <a name="l5651"><span class="ln">5651 </span></a>        wd = Word(alphas) 
5672 <a name="l5652"><span class="ln">5652 </span></a>        for match in locatedExpr(wd).searchString(&quot;ljsdf123lksdjjf123lkkjj1222&quot;): 
5673 <a name="l5653"><span class="ln">5653 </span></a>            print(match) 
5674 <a name="l5654"><span class="ln">5654 </span></a> 
5675 <a name="l5655"><span class="ln">5655 </span></a>    prints:: 
5676 <a name="l5656"><span class="ln">5656 </span></a> 
5677 <a name="l5657"><span class="ln">5657 </span></a>        [[0, 'ljsdf', 5]] 
5678 <a name="l5658"><span class="ln">5658 </span></a>        [[8, 'lksdjjf', 15]] 
5679 <a name="l5659"><span class="ln">5659 </span></a>        [[18, 'lkkjj', 23]] 
5680 <a name="l5660"><span class="ln">5660 </span></a>    &quot;&quot;&quot;</span>
5681 <a name="l5661"><span class="ln">5661 </span></a>    <span class="s1">locator = Empty().setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: l)</span>
5682 <a name="l5662"><span class="ln">5662 </span></a>    <span class="s3">return </span><span class="s1">Group(locator(</span><span class="s2">&quot;locn_start&quot;</span><span class="s1">) + expr(</span><span class="s2">&quot;value&quot;</span><span class="s1">) + locator.copy().leaveWhitespace()(</span><span class="s2">&quot;locn_end&quot;</span><span class="s1">))</span>
5683 <a name="l5663"><span class="ln">5663 </span></a>
5684 <a name="l5664"><span class="ln">5664 </span></a>
5685 <a name="l5665"><span class="ln">5665 </span></a><span class="s0"># convenience constants for positional expressions</span>
5686 <a name="l5666"><span class="ln">5666 </span></a><span class="s1">empty       = Empty().setName(</span><span class="s2">&quot;empty&quot;</span><span class="s1">)</span>
5687 <a name="l5667"><span class="ln">5667 </span></a><span class="s1">lineStart   = LineStart().setName(</span><span class="s2">&quot;lineStart&quot;</span><span class="s1">)</span>
5688 <a name="l5668"><span class="ln">5668 </span></a><span class="s1">lineEnd     = LineEnd().setName(</span><span class="s2">&quot;lineEnd&quot;</span><span class="s1">)</span>
5689 <a name="l5669"><span class="ln">5669 </span></a><span class="s1">stringStart = StringStart().setName(</span><span class="s2">&quot;stringStart&quot;</span><span class="s1">)</span>
5690 <a name="l5670"><span class="ln">5670 </span></a><span class="s1">stringEnd   = StringEnd().setName(</span><span class="s2">&quot;stringEnd&quot;</span><span class="s1">)</span>
5691 <a name="l5671"><span class="ln">5671 </span></a>
5692 <a name="l5672"><span class="ln">5672 </span></a><span class="s1">_escapedPunc = Word(_bslash</span><span class="s3">, </span><span class="s2">r&quot;\[]-*.$+^?()~ &quot;</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">2</span><span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">][</span><span class="s4">1</span><span class="s1">])</span>
5693 <a name="l5673"><span class="ln">5673 </span></a><span class="s1">_escapedHexChar = Regex(</span><span class="s2">r&quot;\\0?[xX][0-9a-fA-F]+&quot;</span><span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: unichr(int(t[</span><span class="s4">0</span><span class="s1">].lstrip(</span><span class="s2">r'\0x'</span><span class="s1">)</span><span class="s3">, </span><span class="s4">16</span><span class="s1">)))</span>
5694 <a name="l5674"><span class="ln">5674 </span></a><span class="s1">_escapedOctChar = Regex(</span><span class="s2">r&quot;\\0[0-7]+&quot;</span><span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: unichr(int(t[</span><span class="s4">0</span><span class="s1">][</span><span class="s4">1</span><span class="s1">:]</span><span class="s3">, </span><span class="s4">8</span><span class="s1">)))</span>
5695 <a name="l5675"><span class="ln">5675 </span></a><span class="s1">_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(</span><span class="s2">r'\]'</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">1</span><span class="s1">)</span>
5696 <a name="l5676"><span class="ln">5676 </span></a><span class="s1">_charRange = Group(_singleChar + Suppress(</span><span class="s2">&quot;-&quot;</span><span class="s1">) + _singleChar)</span>
5697 <a name="l5677"><span class="ln">5677 </span></a><span class="s1">_reBracketExpr = Literal(</span><span class="s2">&quot;[&quot;</span><span class="s1">) + Optional(</span><span class="s2">&quot;^&quot;</span><span class="s1">).setResultsName(</span><span class="s2">&quot;negate&quot;</span><span class="s1">) + Group(OneOrMore(_charRange | _singleChar)).setResultsName(</span><span class="s2">&quot;body&quot;</span><span class="s1">) + </span><span class="s2">&quot;]&quot;</span>
5698 <a name="l5678"><span class="ln">5678 </span></a>
5699 <a name="l5679"><span class="ln">5679 </span></a><span class="s3">def </span><span class="s1">srange(s):</span>
5700 <a name="l5680"><span class="ln">5680 </span></a>    <span class="s5">r&quot;&quot;&quot;Helper to easily define string ranges for use in Word 
5701 <a name="l5681"><span class="ln">5681 </span></a>    construction. Borrows syntax from regexp '[]' string range 
5702 <a name="l5682"><span class="ln">5682 </span></a>    definitions:: 
5703 <a name="l5683"><span class="ln">5683 </span></a> 
5704 <a name="l5684"><span class="ln">5684 </span></a>        srange(&quot;[0-9]&quot;)   -&gt; &quot;0123456789&quot; 
5705 <a name="l5685"><span class="ln">5685 </span></a>        srange(&quot;[a-z]&quot;)   -&gt; &quot;abcdefghijklmnopqrstuvwxyz&quot; 
5706 <a name="l5686"><span class="ln">5686 </span></a>        srange(&quot;[a-z$_]&quot;) -&gt; &quot;abcdefghijklmnopqrstuvwxyz$_&quot; 
5707 <a name="l5687"><span class="ln">5687 </span></a> 
5708 <a name="l5688"><span class="ln">5688 </span></a>    The input string must be enclosed in []'s, and the returned string 
5709 <a name="l5689"><span class="ln">5689 </span></a>    is the expanded character set joined into a single string. The 
5710 <a name="l5690"><span class="ln">5690 </span></a>    values enclosed in the []'s may be: 
5711 <a name="l5691"><span class="ln">5691 </span></a> 
5712 <a name="l5692"><span class="ln">5692 </span></a>     - a single character 
5713 <a name="l5693"><span class="ln">5693 </span></a>     - an escaped character with a leading backslash (such as ``\-`` 
5714 <a name="l5694"><span class="ln">5694 </span></a>       or ``\]``) 
5715 <a name="l5695"><span class="ln">5695 </span></a>     - an escaped hex character with a leading ``'\x'`` 
5716 <a name="l5696"><span class="ln">5696 </span></a>       (``\x21``, which is a ``'!'`` character) (``\0x##`` 
5717 <a name="l5697"><span class="ln">5697 </span></a>       is also supported for backwards compatibility) 
5718 <a name="l5698"><span class="ln">5698 </span></a>     - an escaped octal character with a leading ``'\0'`` 
5719 <a name="l5699"><span class="ln">5699 </span></a>       (``\041``, which is a ``'!'`` character) 
5720 <a name="l5700"><span class="ln">5700 </span></a>     - a range of any of the above, separated by a dash (``'a-z'``, 
5721 <a name="l5701"><span class="ln">5701 </span></a>       etc.) 
5722 <a name="l5702"><span class="ln">5702 </span></a>     - any combination of the above (``'aeiouy'``, 
5723 <a name="l5703"><span class="ln">5703 </span></a>       ``'a-zA-Z0-9_$'``, etc.) 
5724 <a name="l5704"><span class="ln">5704 </span></a>    &quot;&quot;&quot;</span>
5725 <a name="l5705"><span class="ln">5705 </span></a>    <span class="s1">_expanded = </span><span class="s3">lambda </span><span class="s1">p: p </span><span class="s3">if not </span><span class="s1">isinstance(p</span><span class="s3">, </span><span class="s1">ParseResults) </span><span class="s3">else </span><span class="s2">''</span><span class="s1">.join(unichr(c) </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">range(ord(p[</span><span class="s4">0</span><span class="s1">])</span><span class="s3">, </span><span class="s1">ord(p[</span><span class="s4">1</span><span class="s1">]) + </span><span class="s4">1</span><span class="s1">))</span>
5726 <a name="l5706"><span class="ln">5706 </span></a>    <span class="s3">try</span><span class="s1">:</span>
5727 <a name="l5707"><span class="ln">5707 </span></a>        <span class="s3">return </span><span class="s2">&quot;&quot;</span><span class="s1">.join(_expanded(part) </span><span class="s3">for </span><span class="s1">part </span><span class="s3">in </span><span class="s1">_reBracketExpr.parseString(s).body)</span>
5728 <a name="l5708"><span class="ln">5708 </span></a>    <span class="s3">except </span><span class="s1">Exception:</span>
5729 <a name="l5709"><span class="ln">5709 </span></a>        <span class="s3">return </span><span class="s2">&quot;&quot;</span>
5730 <a name="l5710"><span class="ln">5710 </span></a>
5731 <a name="l5711"><span class="ln">5711 </span></a><span class="s3">def </span><span class="s1">matchOnlyAtCol(n):</span>
5732 <a name="l5712"><span class="ln">5712 </span></a>    <span class="s5">&quot;&quot;&quot;Helper method for defining parse actions that require matching at 
5733 <a name="l5713"><span class="ln">5713 </span></a>    a specific column in the input text. 
5734 <a name="l5714"><span class="ln">5714 </span></a>    &quot;&quot;&quot;</span>
5735 <a name="l5715"><span class="ln">5715 </span></a>    <span class="s3">def </span><span class="s1">verifyCol(strg</span><span class="s3">, </span><span class="s1">locn</span><span class="s3">, </span><span class="s1">toks):</span>
5736 <a name="l5716"><span class="ln">5716 </span></a>        <span class="s3">if </span><span class="s1">col(locn</span><span class="s3">, </span><span class="s1">strg) != n:</span>
5737 <a name="l5717"><span class="ln">5717 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(strg</span><span class="s3">, </span><span class="s1">locn</span><span class="s3">, </span><span class="s2">&quot;matched token not at column %d&quot; </span><span class="s1">% n)</span>
5738 <a name="l5718"><span class="ln">5718 </span></a>    <span class="s3">return </span><span class="s1">verifyCol</span>
5739 <a name="l5719"><span class="ln">5719 </span></a>
5740 <a name="l5720"><span class="ln">5720 </span></a><span class="s3">def </span><span class="s1">replaceWith(replStr):</span>
5741 <a name="l5721"><span class="ln">5721 </span></a>    <span class="s5">&quot;&quot;&quot;Helper method for common parse actions that simply return 
5742 <a name="l5722"><span class="ln">5722 </span></a>    a literal value.  Especially useful when used with 
5743 <a name="l5723"><span class="ln">5723 </span></a>    :class:`transformString&lt;ParserElement.transformString&gt;` (). 
5744 <a name="l5724"><span class="ln">5724 </span></a> 
5745 <a name="l5725"><span class="ln">5725 </span></a>    Example:: 
5746 <a name="l5726"><span class="ln">5726 </span></a> 
5747 <a name="l5727"><span class="ln">5727 </span></a>        num = Word(nums).setParseAction(lambda toks: int(toks[0])) 
5748 <a name="l5728"><span class="ln">5728 </span></a>        na = oneOf(&quot;N/A NA&quot;).setParseAction(replaceWith(math.nan)) 
5749 <a name="l5729"><span class="ln">5729 </span></a>        term = na | num 
5750 <a name="l5730"><span class="ln">5730 </span></a> 
5751 <a name="l5731"><span class="ln">5731 </span></a>        OneOrMore(term).parseString(&quot;324 234 N/A 234&quot;) # -&gt; [324, 234, nan, 234] 
5752 <a name="l5732"><span class="ln">5732 </span></a>    &quot;&quot;&quot;</span>
5753 <a name="l5733"><span class="ln">5733 </span></a>    <span class="s3">return lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: [replStr]</span>
5754 <a name="l5734"><span class="ln">5734 </span></a>
5755 <a name="l5735"><span class="ln">5735 </span></a><span class="s3">def </span><span class="s1">removeQuotes(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5756 <a name="l5736"><span class="ln">5736 </span></a>    <span class="s5">&quot;&quot;&quot;Helper parse action for removing quotation marks from parsed 
5757 <a name="l5737"><span class="ln">5737 </span></a>    quoted strings. 
5758 <a name="l5738"><span class="ln">5738 </span></a> 
5759 <a name="l5739"><span class="ln">5739 </span></a>    Example:: 
5760 <a name="l5740"><span class="ln">5740 </span></a> 
5761 <a name="l5741"><span class="ln">5741 </span></a>        # by default, quotation marks are included in parsed results 
5762 <a name="l5742"><span class="ln">5742 </span></a>        quotedString.parseString(&quot;'Now is the Winter of our Discontent'&quot;) # -&gt; [&quot;'Now is the Winter of our Discontent'&quot;] 
5763 <a name="l5743"><span class="ln">5743 </span></a> 
5764 <a name="l5744"><span class="ln">5744 </span></a>        # use removeQuotes to strip quotation marks from parsed results 
5765 <a name="l5745"><span class="ln">5745 </span></a>        quotedString.setParseAction(removeQuotes) 
5766 <a name="l5746"><span class="ln">5746 </span></a>        quotedString.parseString(&quot;'Now is the Winter of our Discontent'&quot;) # -&gt; [&quot;Now is the Winter of our Discontent&quot;] 
5767 <a name="l5747"><span class="ln">5747 </span></a>    &quot;&quot;&quot;</span>
5768 <a name="l5748"><span class="ln">5748 </span></a>    <span class="s3">return </span><span class="s1">t[</span><span class="s4">0</span><span class="s1">][</span><span class="s4">1</span><span class="s1">:-</span><span class="s4">1</span><span class="s1">]</span>
5769 <a name="l5749"><span class="ln">5749 </span></a>
5770 <a name="l5750"><span class="ln">5750 </span></a><span class="s3">def </span><span class="s1">tokenMap(func</span><span class="s3">, </span><span class="s1">*args):</span>
5771 <a name="l5751"><span class="ln">5751 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to define a parse action by mapping a function to all 
5772 <a name="l5752"><span class="ln">5752 </span></a>    elements of a ParseResults list. If any additional args are passed, 
5773 <a name="l5753"><span class="ln">5753 </span></a>    they are forwarded to the given function as additional arguments 
5774 <a name="l5754"><span class="ln">5754 </span></a>    after the token, as in 
5775 <a name="l5755"><span class="ln">5755 </span></a>    ``hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))``, 
5776 <a name="l5756"><span class="ln">5756 </span></a>    which will convert the parsed data to an integer using base 16. 
5777 <a name="l5757"><span class="ln">5757 </span></a> 
5778 <a name="l5758"><span class="ln">5758 </span></a>    Example (compare the last to example in :class:`ParserElement.transformString`:: 
5779 <a name="l5759"><span class="ln">5759 </span></a> 
5780 <a name="l5760"><span class="ln">5760 </span></a>        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16)) 
5781 <a name="l5761"><span class="ln">5761 </span></a>        hex_ints.runTests(''' 
5782 <a name="l5762"><span class="ln">5762 </span></a>            00 11 22 aa FF 0a 0d 1a 
5783 <a name="l5763"><span class="ln">5763 </span></a>            ''') 
5784 <a name="l5764"><span class="ln">5764 </span></a> 
5785 <a name="l5765"><span class="ln">5765 </span></a>        upperword = Word(alphas).setParseAction(tokenMap(str.upper)) 
5786 <a name="l5766"><span class="ln">5766 </span></a>        OneOrMore(upperword).runTests(''' 
5787 <a name="l5767"><span class="ln">5767 </span></a>            my kingdom for a horse 
5788 <a name="l5768"><span class="ln">5768 </span></a>            ''') 
5789 <a name="l5769"><span class="ln">5769 </span></a> 
5790 <a name="l5770"><span class="ln">5770 </span></a>        wd = Word(alphas).setParseAction(tokenMap(str.title)) 
5791 <a name="l5771"><span class="ln">5771 </span></a>        OneOrMore(wd).setParseAction(' '.join).runTests(''' 
5792 <a name="l5772"><span class="ln">5772 </span></a>            now is the winter of our discontent made glorious summer by this sun of york 
5793 <a name="l5773"><span class="ln">5773 </span></a>            ''') 
5794 <a name="l5774"><span class="ln">5774 </span></a> 
5795 <a name="l5775"><span class="ln">5775 </span></a>    prints:: 
5796 <a name="l5776"><span class="ln">5776 </span></a> 
5797 <a name="l5777"><span class="ln">5777 </span></a>        00 11 22 aa FF 0a 0d 1a 
5798 <a name="l5778"><span class="ln">5778 </span></a>        [0, 17, 34, 170, 255, 10, 13, 26] 
5799 <a name="l5779"><span class="ln">5779 </span></a> 
5800 <a name="l5780"><span class="ln">5780 </span></a>        my kingdom for a horse 
5801 <a name="l5781"><span class="ln">5781 </span></a>        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE'] 
5802 <a name="l5782"><span class="ln">5782 </span></a> 
5803 <a name="l5783"><span class="ln">5783 </span></a>        now is the winter of our discontent made glorious summer by this sun of york 
5804 <a name="l5784"><span class="ln">5784 </span></a>        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'] 
5805 <a name="l5785"><span class="ln">5785 </span></a>    &quot;&quot;&quot;</span>
5806 <a name="l5786"><span class="ln">5786 </span></a>    <span class="s3">def </span><span class="s1">pa(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
5807 <a name="l5787"><span class="ln">5787 </span></a>        <span class="s3">return </span><span class="s1">[func(tokn</span><span class="s3">, </span><span class="s1">*args) </span><span class="s3">for </span><span class="s1">tokn </span><span class="s3">in </span><span class="s1">t]</span>
5808 <a name="l5788"><span class="ln">5788 </span></a>
5809 <a name="l5789"><span class="ln">5789 </span></a>    <span class="s3">try</span><span class="s1">:</span>
5810 <a name="l5790"><span class="ln">5790 </span></a>        <span class="s1">func_name = getattr(func</span><span class="s3">, </span><span class="s2">'__name__'</span><span class="s3">,</span>
5811 <a name="l5791"><span class="ln">5791 </span></a>                            <span class="s1">getattr(func</span><span class="s3">, </span><span class="s2">'__class__'</span><span class="s1">).__name__)</span>
5812 <a name="l5792"><span class="ln">5792 </span></a>    <span class="s3">except </span><span class="s1">Exception:</span>
5813 <a name="l5793"><span class="ln">5793 </span></a>        <span class="s1">func_name = str(func)</span>
5814 <a name="l5794"><span class="ln">5794 </span></a>    <span class="s1">pa.__name__ = func_name</span>
5815 <a name="l5795"><span class="ln">5795 </span></a>
5816 <a name="l5796"><span class="ln">5796 </span></a>    <span class="s3">return </span><span class="s1">pa</span>
5817 <a name="l5797"><span class="ln">5797 </span></a>
5818 <a name="l5798"><span class="ln">5798 </span></a><span class="s1">upcaseTokens = tokenMap(</span><span class="s3">lambda </span><span class="s1">t: _ustr(t).upper())</span>
5819 <a name="l5799"><span class="ln">5799 </span></a><span class="s2">&quot;&quot;&quot;(Deprecated) Helper parse action to convert tokens to upper case. 
5820 <a name="l5800"><span class="ln">5800 </span></a>Deprecated in favor of :class:`pyparsing_common.upcaseTokens`&quot;&quot;&quot;</span>
5821 <a name="l5801"><span class="ln">5801 </span></a>
5822 <a name="l5802"><span class="ln">5802 </span></a><span class="s1">downcaseTokens = tokenMap(</span><span class="s3">lambda </span><span class="s1">t: _ustr(t).lower())</span>
5823 <a name="l5803"><span class="ln">5803 </span></a><span class="s2">&quot;&quot;&quot;(Deprecated) Helper parse action to convert tokens to lower case. 
5824 <a name="l5804"><span class="ln">5804 </span></a>Deprecated in favor of :class:`pyparsing_common.downcaseTokens`&quot;&quot;&quot;</span>
5825 <a name="l5805"><span class="ln">5805 </span></a>
5826 <a name="l5806"><span class="ln">5806 </span></a><span class="s3">def </span><span class="s1">_makeTags(tagStr</span><span class="s3">, </span><span class="s1">xml</span><span class="s3">,</span>
5827 <a name="l5807"><span class="ln">5807 </span></a>              <span class="s1">suppress_LT=Suppress(</span><span class="s2">&quot;&lt;&quot;</span><span class="s1">)</span><span class="s3">,</span>
5828 <a name="l5808"><span class="ln">5808 </span></a>              <span class="s1">suppress_GT=Suppress(</span><span class="s2">&quot;&gt;&quot;</span><span class="s1">)):</span>
5829 <a name="l5809"><span class="ln">5809 </span></a>    <span class="s5">&quot;&quot;&quot;Internal helper to construct opening and closing tag expressions, given a tag name&quot;&quot;&quot;</span>
5830 <a name="l5810"><span class="ln">5810 </span></a>    <span class="s3">if </span><span class="s1">isinstance(tagStr</span><span class="s3">, </span><span class="s1">basestring):</span>
5831 <a name="l5811"><span class="ln">5811 </span></a>        <span class="s1">resname = tagStr</span>
5832 <a name="l5812"><span class="ln">5812 </span></a>        <span class="s1">tagStr = Keyword(tagStr</span><span class="s3">, </span><span class="s1">caseless=</span><span class="s3">not </span><span class="s1">xml)</span>
5833 <a name="l5813"><span class="ln">5813 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5834 <a name="l5814"><span class="ln">5814 </span></a>        <span class="s1">resname = tagStr.name</span>
5835 <a name="l5815"><span class="ln">5815 </span></a>
5836 <a name="l5816"><span class="ln">5816 </span></a>    <span class="s1">tagAttrName = Word(alphas</span><span class="s3">, </span><span class="s1">alphanums + </span><span class="s2">&quot;_-:&quot;</span><span class="s1">)</span>
5837 <a name="l5817"><span class="ln">5817 </span></a>    <span class="s3">if </span><span class="s1">xml:</span>
5838 <a name="l5818"><span class="ln">5818 </span></a>        <span class="s1">tagAttrValue = dblQuotedString.copy().setParseAction(removeQuotes)</span>
5839 <a name="l5819"><span class="ln">5819 </span></a>        <span class="s1">openTag = (suppress_LT</span>
5840 <a name="l5820"><span class="ln">5820 </span></a>                   <span class="s1">+ tagStr(</span><span class="s2">&quot;tag&quot;</span><span class="s1">)</span>
5841 <a name="l5821"><span class="ln">5821 </span></a>                   <span class="s1">+ Dict(ZeroOrMore(Group(tagAttrName + Suppress(</span><span class="s2">&quot;=&quot;</span><span class="s1">) + tagAttrValue)))</span>
5842 <a name="l5822"><span class="ln">5822 </span></a>                   <span class="s1">+ Optional(</span><span class="s2">&quot;/&quot;</span><span class="s3">, </span><span class="s1">default=[</span><span class="s3">False</span><span class="s1">])(</span><span class="s2">&quot;empty&quot;</span><span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">] == </span><span class="s2">'/'</span><span class="s1">)</span>
5843 <a name="l5823"><span class="ln">5823 </span></a>                   <span class="s1">+ suppress_GT)</span>
5844 <a name="l5824"><span class="ln">5824 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5845 <a name="l5825"><span class="ln">5825 </span></a>        <span class="s1">tagAttrValue = quotedString.copy().setParseAction(removeQuotes) | Word(printables</span><span class="s3">, </span><span class="s1">excludeChars=</span><span class="s2">&quot;&gt;&quot;</span><span class="s1">)</span>
5846 <a name="l5826"><span class="ln">5826 </span></a>        <span class="s1">openTag = (suppress_LT</span>
5847 <a name="l5827"><span class="ln">5827 </span></a>                   <span class="s1">+ tagStr(</span><span class="s2">&quot;tag&quot;</span><span class="s1">)</span>
5848 <a name="l5828"><span class="ln">5828 </span></a>                   <span class="s1">+ Dict(ZeroOrMore(Group(tagAttrName.setParseAction(downcaseTokens)</span>
5849 <a name="l5829"><span class="ln">5829 </span></a>                                           <span class="s1">+ Optional(Suppress(</span><span class="s2">&quot;=&quot;</span><span class="s1">) + tagAttrValue))))</span>
5850 <a name="l5830"><span class="ln">5830 </span></a>                   <span class="s1">+ Optional(</span><span class="s2">&quot;/&quot;</span><span class="s3">, </span><span class="s1">default=[</span><span class="s3">False</span><span class="s1">])(</span><span class="s2">&quot;empty&quot;</span><span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">] == </span><span class="s2">'/'</span><span class="s1">)</span>
5851 <a name="l5831"><span class="ln">5831 </span></a>                   <span class="s1">+ suppress_GT)</span>
5852 <a name="l5832"><span class="ln">5832 </span></a>    <span class="s1">closeTag = Combine(_L(</span><span class="s2">&quot;&lt;/&quot;</span><span class="s1">) + tagStr + </span><span class="s2">&quot;&gt;&quot;</span><span class="s3">, </span><span class="s1">adjacent=</span><span class="s3">False</span><span class="s1">)</span>
5853 <a name="l5833"><span class="ln">5833 </span></a>
5854 <a name="l5834"><span class="ln">5834 </span></a>    <span class="s1">openTag.setName(</span><span class="s2">&quot;&lt;%s&gt;&quot; </span><span class="s1">% resname)</span>
5855 <a name="l5835"><span class="ln">5835 </span></a>    <span class="s0"># add start&lt;tagname&gt; results name in parse action now that ungrouped names are not reported at two levels</span>
5856 <a name="l5836"><span class="ln">5836 </span></a>    <span class="s1">openTag.addParseAction(</span><span class="s3">lambda </span><span class="s1">t: t.__setitem__(</span><span class="s2">&quot;start&quot; </span><span class="s1">+ </span><span class="s2">&quot;&quot;</span><span class="s1">.join(resname.replace(</span><span class="s2">&quot;:&quot;</span><span class="s3">, </span><span class="s2">&quot; &quot;</span><span class="s1">).title().split())</span><span class="s3">, </span><span class="s1">t.copy()))</span>
5857 <a name="l5837"><span class="ln">5837 </span></a>    <span class="s1">closeTag = closeTag(</span><span class="s2">&quot;end&quot; </span><span class="s1">+ </span><span class="s2">&quot;&quot;</span><span class="s1">.join(resname.replace(</span><span class="s2">&quot;:&quot;</span><span class="s3">, </span><span class="s2">&quot; &quot;</span><span class="s1">).title().split())).setName(</span><span class="s2">&quot;&lt;/%s&gt;&quot; </span><span class="s1">% resname)</span>
5858 <a name="l5838"><span class="ln">5838 </span></a>    <span class="s1">openTag.tag = resname</span>
5859 <a name="l5839"><span class="ln">5839 </span></a>    <span class="s1">closeTag.tag = resname</span>
5860 <a name="l5840"><span class="ln">5840 </span></a>    <span class="s1">openTag.tag_body = SkipTo(closeTag())</span>
5861 <a name="l5841"><span class="ln">5841 </span></a>    <span class="s3">return </span><span class="s1">openTag</span><span class="s3">, </span><span class="s1">closeTag</span>
5862 <a name="l5842"><span class="ln">5842 </span></a>
5863 <a name="l5843"><span class="ln">5843 </span></a><span class="s3">def </span><span class="s1">makeHTMLTags(tagStr):</span>
5864 <a name="l5844"><span class="ln">5844 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to construct opening and closing tag expressions for HTML, 
5865 <a name="l5845"><span class="ln">5845 </span></a>    given a tag name. Matches tags in either upper or lower case, 
5866 <a name="l5846"><span class="ln">5846 </span></a>    attributes with namespaces and with quoted or unquoted values. 
5867 <a name="l5847"><span class="ln">5847 </span></a> 
5868 <a name="l5848"><span class="ln">5848 </span></a>    Example:: 
5869 <a name="l5849"><span class="ln">5849 </span></a> 
5870 <a name="l5850"><span class="ln">5850 </span></a>        text = '&lt;td&gt;More info at the &lt;a href=&quot;https://github.com/pyparsing/pyparsing/wiki&quot;&gt;pyparsing&lt;/a&gt; wiki page&lt;/td&gt;' 
5871 <a name="l5851"><span class="ln">5851 </span></a>        # makeHTMLTags returns pyparsing expressions for the opening and 
5872 <a name="l5852"><span class="ln">5852 </span></a>        # closing tags as a 2-tuple 
5873 <a name="l5853"><span class="ln">5853 </span></a>        a, a_end = makeHTMLTags(&quot;A&quot;) 
5874 <a name="l5854"><span class="ln">5854 </span></a>        link_expr = a + SkipTo(a_end)(&quot;link_text&quot;) + a_end 
5875 <a name="l5855"><span class="ln">5855 </span></a> 
5876 <a name="l5856"><span class="ln">5856 </span></a>        for link in link_expr.searchString(text): 
5877 <a name="l5857"><span class="ln">5857 </span></a>            # attributes in the &lt;A&gt; tag (like &quot;href&quot; shown here) are 
5878 <a name="l5858"><span class="ln">5858 </span></a>            # also accessible as named results 
5879 <a name="l5859"><span class="ln">5859 </span></a>            print(link.link_text, '-&gt;', link.href) 
5880 <a name="l5860"><span class="ln">5860 </span></a> 
5881 <a name="l5861"><span class="ln">5861 </span></a>    prints:: 
5882 <a name="l5862"><span class="ln">5862 </span></a> 
5883 <a name="l5863"><span class="ln">5863 </span></a>        pyparsing -&gt; https://github.com/pyparsing/pyparsing/wiki 
5884 <a name="l5864"><span class="ln">5864 </span></a>    &quot;&quot;&quot;</span>
5885 <a name="l5865"><span class="ln">5865 </span></a>    <span class="s3">return </span><span class="s1">_makeTags(tagStr</span><span class="s3">, False</span><span class="s1">)</span>
5886 <a name="l5866"><span class="ln">5866 </span></a>
5887 <a name="l5867"><span class="ln">5867 </span></a><span class="s3">def </span><span class="s1">makeXMLTags(tagStr):</span>
5888 <a name="l5868"><span class="ln">5868 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to construct opening and closing tag expressions for XML, 
5889 <a name="l5869"><span class="ln">5869 </span></a>    given a tag name. Matches tags only in the given upper/lower case. 
5890 <a name="l5870"><span class="ln">5870 </span></a> 
5891 <a name="l5871"><span class="ln">5871 </span></a>    Example: similar to :class:`makeHTMLTags` 
5892 <a name="l5872"><span class="ln">5872 </span></a>    &quot;&quot;&quot;</span>
5893 <a name="l5873"><span class="ln">5873 </span></a>    <span class="s3">return </span><span class="s1">_makeTags(tagStr</span><span class="s3">, True</span><span class="s1">)</span>
5894 <a name="l5874"><span class="ln">5874 </span></a>
5895 <a name="l5875"><span class="ln">5875 </span></a><span class="s3">def </span><span class="s1">withAttribute(*args</span><span class="s3">, </span><span class="s1">**attrDict):</span>
5896 <a name="l5876"><span class="ln">5876 </span></a>    <span class="s5">&quot;&quot;&quot;Helper to create a validating parse action to be used with start 
5897 <a name="l5877"><span class="ln">5877 </span></a>    tags created with :class:`makeXMLTags` or 
5898 <a name="l5878"><span class="ln">5878 </span></a>    :class:`makeHTMLTags`. Use ``withAttribute`` to qualify 
5899 <a name="l5879"><span class="ln">5879 </span></a>    a starting tag with a required attribute value, to avoid false 
5900 <a name="l5880"><span class="ln">5880 </span></a>    matches on common tags such as ``&lt;TD&gt;`` or ``&lt;DIV&gt;``. 
5901 <a name="l5881"><span class="ln">5881 </span></a> 
5902 <a name="l5882"><span class="ln">5882 </span></a>    Call ``withAttribute`` with a series of attribute names and 
5903 <a name="l5883"><span class="ln">5883 </span></a>    values. Specify the list of filter attributes names and values as: 
5904 <a name="l5884"><span class="ln">5884 </span></a> 
5905 <a name="l5885"><span class="ln">5885 </span></a>     - keyword arguments, as in ``(align=&quot;right&quot;)``, or 
5906 <a name="l5886"><span class="ln">5886 </span></a>     - as an explicit dict with ``**`` operator, when an attribute 
5907 <a name="l5887"><span class="ln">5887 </span></a>       name is also a Python reserved word, as in ``**{&quot;class&quot;:&quot;Customer&quot;, &quot;align&quot;:&quot;right&quot;}`` 
5908 <a name="l5888"><span class="ln">5888 </span></a>     - a list of name-value tuples, as in ``((&quot;ns1:class&quot;, &quot;Customer&quot;), (&quot;ns2:align&quot;, &quot;right&quot;))`` 
5909 <a name="l5889"><span class="ln">5889 </span></a> 
5910 <a name="l5890"><span class="ln">5890 </span></a>    For attribute names with a namespace prefix, you must use the second 
5911 <a name="l5891"><span class="ln">5891 </span></a>    form.  Attribute names are matched insensitive to upper/lower case. 
5912 <a name="l5892"><span class="ln">5892 </span></a> 
5913 <a name="l5893"><span class="ln">5893 </span></a>    If just testing for ``class`` (with or without a namespace), use 
5914 <a name="l5894"><span class="ln">5894 </span></a>    :class:`withClass`. 
5915 <a name="l5895"><span class="ln">5895 </span></a> 
5916 <a name="l5896"><span class="ln">5896 </span></a>    To verify that the attribute exists, but without specifying a value, 
5917 <a name="l5897"><span class="ln">5897 </span></a>    pass ``withAttribute.ANY_VALUE`` as the value. 
5918 <a name="l5898"><span class="ln">5898 </span></a> 
5919 <a name="l5899"><span class="ln">5899 </span></a>    Example:: 
5920 <a name="l5900"><span class="ln">5900 </span></a> 
5921 <a name="l5901"><span class="ln">5901 </span></a>        html = ''' 
5922 <a name="l5902"><span class="ln">5902 </span></a>            &lt;div&gt; 
5923 <a name="l5903"><span class="ln">5903 </span></a>            Some text 
5924 <a name="l5904"><span class="ln">5904 </span></a>            &lt;div type=&quot;grid&quot;&gt;1 4 0 1 0&lt;/div&gt; 
5925 <a name="l5905"><span class="ln">5905 </span></a>            &lt;div type=&quot;graph&quot;&gt;1,3 2,3 1,1&lt;/div&gt; 
5926 <a name="l5906"><span class="ln">5906 </span></a>            &lt;div&gt;this has no type&lt;/div&gt; 
5927 <a name="l5907"><span class="ln">5907 </span></a>            &lt;/div&gt; 
5928 <a name="l5908"><span class="ln">5908 </span></a> 
5929 <a name="l5909"><span class="ln">5909 </span></a>        ''' 
5930 <a name="l5910"><span class="ln">5910 </span></a>        div,div_end = makeHTMLTags(&quot;div&quot;) 
5931 <a name="l5911"><span class="ln">5911 </span></a> 
5932 <a name="l5912"><span class="ln">5912 </span></a>        # only match div tag having a type attribute with value &quot;grid&quot; 
5933 <a name="l5913"><span class="ln">5913 </span></a>        div_grid = div().setParseAction(withAttribute(type=&quot;grid&quot;)) 
5934 <a name="l5914"><span class="ln">5914 </span></a>        grid_expr = div_grid + SkipTo(div | div_end)(&quot;body&quot;) 
5935 <a name="l5915"><span class="ln">5915 </span></a>        for grid_header in grid_expr.searchString(html): 
5936 <a name="l5916"><span class="ln">5916 </span></a>            print(grid_header.body) 
5937 <a name="l5917"><span class="ln">5917 </span></a> 
5938 <a name="l5918"><span class="ln">5918 </span></a>        # construct a match with any div tag having a type attribute, regardless of the value 
5939 <a name="l5919"><span class="ln">5919 </span></a>        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE)) 
5940 <a name="l5920"><span class="ln">5920 </span></a>        div_expr = div_any_type + SkipTo(div | div_end)(&quot;body&quot;) 
5941 <a name="l5921"><span class="ln">5921 </span></a>        for div_header in div_expr.searchString(html): 
5942 <a name="l5922"><span class="ln">5922 </span></a>            print(div_header.body) 
5943 <a name="l5923"><span class="ln">5923 </span></a> 
5944 <a name="l5924"><span class="ln">5924 </span></a>    prints:: 
5945 <a name="l5925"><span class="ln">5925 </span></a> 
5946 <a name="l5926"><span class="ln">5926 </span></a>        1 4 0 1 0 
5947 <a name="l5927"><span class="ln">5927 </span></a> 
5948 <a name="l5928"><span class="ln">5928 </span></a>        1 4 0 1 0 
5949 <a name="l5929"><span class="ln">5929 </span></a>        1,3 2,3 1,1 
5950 <a name="l5930"><span class="ln">5930 </span></a>    &quot;&quot;&quot;</span>
5951 <a name="l5931"><span class="ln">5931 </span></a>    <span class="s3">if </span><span class="s1">args:</span>
5952 <a name="l5932"><span class="ln">5932 </span></a>        <span class="s1">attrs = args[:]</span>
5953 <a name="l5933"><span class="ln">5933 </span></a>    <span class="s3">else</span><span class="s1">:</span>
5954 <a name="l5934"><span class="ln">5934 </span></a>        <span class="s1">attrs = attrDict.items()</span>
5955 <a name="l5935"><span class="ln">5935 </span></a>    <span class="s1">attrs = [(k</span><span class="s3">, </span><span class="s1">v) </span><span class="s3">for </span><span class="s1">k</span><span class="s3">, </span><span class="s1">v </span><span class="s3">in </span><span class="s1">attrs]</span>
5956 <a name="l5936"><span class="ln">5936 </span></a>    <span class="s3">def </span><span class="s1">pa(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">tokens):</span>
5957 <a name="l5937"><span class="ln">5937 </span></a>        <span class="s3">for </span><span class="s1">attrName</span><span class="s3">, </span><span class="s1">attrValue </span><span class="s3">in </span><span class="s1">attrs:</span>
5958 <a name="l5938"><span class="ln">5938 </span></a>            <span class="s3">if </span><span class="s1">attrName </span><span class="s3">not in </span><span class="s1">tokens:</span>
5959 <a name="l5939"><span class="ln">5939 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;no matching attribute &quot; </span><span class="s1">+ attrName)</span>
5960 <a name="l5940"><span class="ln">5940 </span></a>            <span class="s3">if </span><span class="s1">attrValue != withAttribute.ANY_VALUE </span><span class="s3">and </span><span class="s1">tokens[attrName] != attrValue:</span>
5961 <a name="l5941"><span class="ln">5941 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;attribute '%s' has value '%s', must be '%s'&quot; </span><span class="s1">%</span>
5962 <a name="l5942"><span class="ln">5942 </span></a>                                            <span class="s1">(attrName</span><span class="s3">, </span><span class="s1">tokens[attrName]</span><span class="s3">, </span><span class="s1">attrValue))</span>
5963 <a name="l5943"><span class="ln">5943 </span></a>    <span class="s3">return </span><span class="s1">pa</span>
5964 <a name="l5944"><span class="ln">5944 </span></a><span class="s1">withAttribute.ANY_VALUE = object()</span>
5965 <a name="l5945"><span class="ln">5945 </span></a>
5966 <a name="l5946"><span class="ln">5946 </span></a><span class="s3">def </span><span class="s1">withClass(classname</span><span class="s3">, </span><span class="s1">namespace=</span><span class="s2">''</span><span class="s1">):</span>
5967 <a name="l5947"><span class="ln">5947 </span></a>    <span class="s5">&quot;&quot;&quot;Simplified version of :class:`withAttribute` when 
5968 <a name="l5948"><span class="ln">5948 </span></a>    matching on a div class - made difficult because ``class`` is 
5969 <a name="l5949"><span class="ln">5949 </span></a>    a reserved word in Python. 
5970 <a name="l5950"><span class="ln">5950 </span></a> 
5971 <a name="l5951"><span class="ln">5951 </span></a>    Example:: 
5972 <a name="l5952"><span class="ln">5952 </span></a> 
5973 <a name="l5953"><span class="ln">5953 </span></a>        html = ''' 
5974 <a name="l5954"><span class="ln">5954 </span></a>            &lt;div&gt; 
5975 <a name="l5955"><span class="ln">5955 </span></a>            Some text 
5976 <a name="l5956"><span class="ln">5956 </span></a>            &lt;div class=&quot;grid&quot;&gt;1 4 0 1 0&lt;/div&gt; 
5977 <a name="l5957"><span class="ln">5957 </span></a>            &lt;div class=&quot;graph&quot;&gt;1,3 2,3 1,1&lt;/div&gt; 
5978 <a name="l5958"><span class="ln">5958 </span></a>            &lt;div&gt;this &amp;lt;div&amp;gt; has no class&lt;/div&gt; 
5979 <a name="l5959"><span class="ln">5959 </span></a>            &lt;/div&gt; 
5980 <a name="l5960"><span class="ln">5960 </span></a> 
5981 <a name="l5961"><span class="ln">5961 </span></a>        ''' 
5982 <a name="l5962"><span class="ln">5962 </span></a>        div,div_end = makeHTMLTags(&quot;div&quot;) 
5983 <a name="l5963"><span class="ln">5963 </span></a>        div_grid = div().setParseAction(withClass(&quot;grid&quot;)) 
5984 <a name="l5964"><span class="ln">5964 </span></a> 
5985 <a name="l5965"><span class="ln">5965 </span></a>        grid_expr = div_grid + SkipTo(div | div_end)(&quot;body&quot;) 
5986 <a name="l5966"><span class="ln">5966 </span></a>        for grid_header in grid_expr.searchString(html): 
5987 <a name="l5967"><span class="ln">5967 </span></a>            print(grid_header.body) 
5988 <a name="l5968"><span class="ln">5968 </span></a> 
5989 <a name="l5969"><span class="ln">5969 </span></a>        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE)) 
5990 <a name="l5970"><span class="ln">5970 </span></a>        div_expr = div_any_type + SkipTo(div | div_end)(&quot;body&quot;) 
5991 <a name="l5971"><span class="ln">5971 </span></a>        for div_header in div_expr.searchString(html): 
5992 <a name="l5972"><span class="ln">5972 </span></a>            print(div_header.body) 
5993 <a name="l5973"><span class="ln">5973 </span></a> 
5994 <a name="l5974"><span class="ln">5974 </span></a>    prints:: 
5995 <a name="l5975"><span class="ln">5975 </span></a> 
5996 <a name="l5976"><span class="ln">5976 </span></a>        1 4 0 1 0 
5997 <a name="l5977"><span class="ln">5977 </span></a> 
5998 <a name="l5978"><span class="ln">5978 </span></a>        1 4 0 1 0 
5999 <a name="l5979"><span class="ln">5979 </span></a>        1,3 2,3 1,1 
6000 <a name="l5980"><span class="ln">5980 </span></a>    &quot;&quot;&quot;</span>
6001 <a name="l5981"><span class="ln">5981 </span></a>    <span class="s1">classattr = </span><span class="s2">&quot;%s:class&quot; </span><span class="s1">% namespace </span><span class="s3">if </span><span class="s1">namespace </span><span class="s3">else </span><span class="s2">&quot;class&quot;</span>
6002 <a name="l5982"><span class="ln">5982 </span></a>    <span class="s3">return </span><span class="s1">withAttribute(**{classattr: classname})</span>
6003 <a name="l5983"><span class="ln">5983 </span></a>
6004 <a name="l5984"><span class="ln">5984 </span></a><span class="s1">opAssoc = SimpleNamespace()</span>
6005 <a name="l5985"><span class="ln">5985 </span></a><span class="s1">opAssoc.LEFT = object()</span>
6006 <a name="l5986"><span class="ln">5986 </span></a><span class="s1">opAssoc.RIGHT = object()</span>
6007 <a name="l5987"><span class="ln">5987 </span></a>
6008 <a name="l5988"><span class="ln">5988 </span></a><span class="s3">def </span><span class="s1">infixNotation(baseExpr</span><span class="s3">, </span><span class="s1">opList</span><span class="s3">, </span><span class="s1">lpar=Suppress(</span><span class="s2">'('</span><span class="s1">)</span><span class="s3">, </span><span class="s1">rpar=Suppress(</span><span class="s2">')'</span><span class="s1">)):</span>
6009 <a name="l5989"><span class="ln">5989 </span></a>    <span class="s5">&quot;&quot;&quot;Helper method for constructing grammars of expressions made up of 
6010 <a name="l5990"><span class="ln">5990 </span></a>    operators working in a precedence hierarchy.  Operators may be unary 
6011 <a name="l5991"><span class="ln">5991 </span></a>    or binary, left- or right-associative.  Parse actions can also be 
6012 <a name="l5992"><span class="ln">5992 </span></a>    attached to operator expressions. The generated parser will also 
6013 <a name="l5993"><span class="ln">5993 </span></a>    recognize the use of parentheses to override operator precedences 
6014 <a name="l5994"><span class="ln">5994 </span></a>    (see example below). 
6015 <a name="l5995"><span class="ln">5995 </span></a> 
6016 <a name="l5996"><span class="ln">5996 </span></a>    Note: if you define a deep operator list, you may see performance 
6017 <a name="l5997"><span class="ln">5997 </span></a>    issues when using infixNotation. See 
6018 <a name="l5998"><span class="ln">5998 </span></a>    :class:`ParserElement.enablePackrat` for a mechanism to potentially 
6019 <a name="l5999"><span class="ln">5999 </span></a>    improve your parser performance. 
6020 <a name="l6000"><span class="ln">6000 </span></a> 
6021 <a name="l6001"><span class="ln">6001 </span></a>    Parameters: 
6022 <a name="l6002"><span class="ln">6002 </span></a>     - baseExpr - expression representing the most basic element for the 
6023 <a name="l6003"><span class="ln">6003 </span></a>       nested 
6024 <a name="l6004"><span class="ln">6004 </span></a>     - opList - list of tuples, one for each operator precedence level 
6025 <a name="l6005"><span class="ln">6005 </span></a>       in the expression grammar; each tuple is of the form ``(opExpr, 
6026 <a name="l6006"><span class="ln">6006 </span></a>       numTerms, rightLeftAssoc, parseAction)``, where: 
6027 <a name="l6007"><span class="ln">6007 </span></a> 
6028 <a name="l6008"><span class="ln">6008 </span></a>       - opExpr is the pyparsing expression for the operator; may also 
6029 <a name="l6009"><span class="ln">6009 </span></a>         be a string, which will be converted to a Literal; if numTerms 
6030 <a name="l6010"><span class="ln">6010 </span></a>         is 3, opExpr is a tuple of two expressions, for the two 
6031 <a name="l6011"><span class="ln">6011 </span></a>         operators separating the 3 terms 
6032 <a name="l6012"><span class="ln">6012 </span></a>       - numTerms is the number of terms for this operator (must be 1, 
6033 <a name="l6013"><span class="ln">6013 </span></a>         2, or 3) 
6034 <a name="l6014"><span class="ln">6014 </span></a>       - rightLeftAssoc is the indicator whether the operator is right 
6035 <a name="l6015"><span class="ln">6015 </span></a>         or left associative, using the pyparsing-defined constants 
6036 <a name="l6016"><span class="ln">6016 </span></a>         ``opAssoc.RIGHT`` and ``opAssoc.LEFT``. 
6037 <a name="l6017"><span class="ln">6017 </span></a>       - parseAction is the parse action to be associated with 
6038 <a name="l6018"><span class="ln">6018 </span></a>         expressions matching this operator expression (the parse action 
6039 <a name="l6019"><span class="ln">6019 </span></a>         tuple member may be omitted); if the parse action is passed 
6040 <a name="l6020"><span class="ln">6020 </span></a>         a tuple or list of functions, this is equivalent to calling 
6041 <a name="l6021"><span class="ln">6021 </span></a>         ``setParseAction(*fn)`` 
6042 <a name="l6022"><span class="ln">6022 </span></a>         (:class:`ParserElement.setParseAction`) 
6043 <a name="l6023"><span class="ln">6023 </span></a>     - lpar - expression for matching left-parentheses 
6044 <a name="l6024"><span class="ln">6024 </span></a>       (default= ``Suppress('(')``) 
6045 <a name="l6025"><span class="ln">6025 </span></a>     - rpar - expression for matching right-parentheses 
6046 <a name="l6026"><span class="ln">6026 </span></a>       (default= ``Suppress(')')``) 
6047 <a name="l6027"><span class="ln">6027 </span></a> 
6048 <a name="l6028"><span class="ln">6028 </span></a>    Example:: 
6049 <a name="l6029"><span class="ln">6029 </span></a> 
6050 <a name="l6030"><span class="ln">6030 </span></a>        # simple example of four-function arithmetic with ints and 
6051 <a name="l6031"><span class="ln">6031 </span></a>        # variable names 
6052 <a name="l6032"><span class="ln">6032 </span></a>        integer = pyparsing_common.signed_integer 
6053 <a name="l6033"><span class="ln">6033 </span></a>        varname = pyparsing_common.identifier 
6054 <a name="l6034"><span class="ln">6034 </span></a> 
6055 <a name="l6035"><span class="ln">6035 </span></a>        arith_expr = infixNotation(integer | varname, 
6056 <a name="l6036"><span class="ln">6036 </span></a>            [ 
6057 <a name="l6037"><span class="ln">6037 </span></a>            ('-', 1, opAssoc.RIGHT), 
6058 <a name="l6038"><span class="ln">6038 </span></a>            (oneOf('* /'), 2, opAssoc.LEFT), 
6059 <a name="l6039"><span class="ln">6039 </span></a>            (oneOf('+ -'), 2, opAssoc.LEFT), 
6060 <a name="l6040"><span class="ln">6040 </span></a>            ]) 
6061 <a name="l6041"><span class="ln">6041 </span></a> 
6062 <a name="l6042"><span class="ln">6042 </span></a>        arith_expr.runTests(''' 
6063 <a name="l6043"><span class="ln">6043 </span></a>            5+3*6 
6064 <a name="l6044"><span class="ln">6044 </span></a>            (5+3)*6 
6065 <a name="l6045"><span class="ln">6045 </span></a>            -2--11 
6066 <a name="l6046"><span class="ln">6046 </span></a>            ''', fullDump=False) 
6067 <a name="l6047"><span class="ln">6047 </span></a> 
6068 <a name="l6048"><span class="ln">6048 </span></a>    prints:: 
6069 <a name="l6049"><span class="ln">6049 </span></a> 
6070 <a name="l6050"><span class="ln">6050 </span></a>        5+3*6 
6071 <a name="l6051"><span class="ln">6051 </span></a>        [[5, '+', [3, '*', 6]]] 
6072 <a name="l6052"><span class="ln">6052 </span></a> 
6073 <a name="l6053"><span class="ln">6053 </span></a>        (5+3)*6 
6074 <a name="l6054"><span class="ln">6054 </span></a>        [[[5, '+', 3], '*', 6]] 
6075 <a name="l6055"><span class="ln">6055 </span></a> 
6076 <a name="l6056"><span class="ln">6056 </span></a>        -2--11 
6077 <a name="l6057"><span class="ln">6057 </span></a>        [[['-', 2], '-', ['-', 11]]] 
6078 <a name="l6058"><span class="ln">6058 </span></a>    &quot;&quot;&quot;</span>
6079 <a name="l6059"><span class="ln">6059 </span></a>    <span class="s0"># captive version of FollowedBy that does not do parse actions or capture results names</span>
6080 <a name="l6060"><span class="ln">6060 </span></a>    <span class="s3">class </span><span class="s1">_FB(FollowedBy):</span>
6081 <a name="l6061"><span class="ln">6061 </span></a>        <span class="s3">def </span><span class="s1">parseImpl(self</span><span class="s3">, </span><span class="s1">instring</span><span class="s3">, </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">doActions=</span><span class="s3">True</span><span class="s1">):</span>
6082 <a name="l6062"><span class="ln">6062 </span></a>            <span class="s1">self.expr.tryParse(instring</span><span class="s3">, </span><span class="s1">loc)</span>
6083 <a name="l6063"><span class="ln">6063 </span></a>            <span class="s3">return </span><span class="s1">loc</span><span class="s3">, </span><span class="s1">[]</span>
6084 <a name="l6064"><span class="ln">6064 </span></a>
6085 <a name="l6065"><span class="ln">6065 </span></a>    <span class="s1">ret = Forward()</span>
6086 <a name="l6066"><span class="ln">6066 </span></a>    <span class="s1">lastExpr = baseExpr | (lpar + ret + rpar)</span>
6087 <a name="l6067"><span class="ln">6067 </span></a>    <span class="s3">for </span><span class="s1">i</span><span class="s3">, </span><span class="s1">operDef </span><span class="s3">in </span><span class="s1">enumerate(opList):</span>
6088 <a name="l6068"><span class="ln">6068 </span></a>        <span class="s1">opExpr</span><span class="s3">, </span><span class="s1">arity</span><span class="s3">, </span><span class="s1">rightLeftAssoc</span><span class="s3">, </span><span class="s1">pa = (operDef + (</span><span class="s3">None, </span><span class="s1">))[:</span><span class="s4">4</span><span class="s1">]</span>
6089 <a name="l6069"><span class="ln">6069 </span></a>        <span class="s1">termName = </span><span class="s2">&quot;%s term&quot; </span><span class="s1">% opExpr </span><span class="s3">if </span><span class="s1">arity &lt; </span><span class="s4">3 </span><span class="s3">else </span><span class="s2">&quot;%s%s term&quot; </span><span class="s1">% opExpr</span>
6090 <a name="l6070"><span class="ln">6070 </span></a>        <span class="s3">if </span><span class="s1">arity == </span><span class="s4">3</span><span class="s1">:</span>
6091 <a name="l6071"><span class="ln">6071 </span></a>            <span class="s3">if </span><span class="s1">opExpr </span><span class="s3">is None or </span><span class="s1">len(opExpr) != </span><span class="s4">2</span><span class="s1">:</span>
6092 <a name="l6072"><span class="ln">6072 </span></a>                <span class="s3">raise </span><span class="s1">ValueError(</span>
6093 <a name="l6073"><span class="ln">6073 </span></a>                    <span class="s2">&quot;if numterms=3, opExpr must be a tuple or list of two expressions&quot;</span><span class="s1">)</span>
6094 <a name="l6074"><span class="ln">6074 </span></a>            <span class="s1">opExpr1</span><span class="s3">, </span><span class="s1">opExpr2 = opExpr</span>
6095 <a name="l6075"><span class="ln">6075 </span></a>        <span class="s1">thisExpr = Forward().setName(termName)</span>
6096 <a name="l6076"><span class="ln">6076 </span></a>        <span class="s3">if </span><span class="s1">rightLeftAssoc == opAssoc.LEFT:</span>
6097 <a name="l6077"><span class="ln">6077 </span></a>            <span class="s3">if </span><span class="s1">arity == </span><span class="s4">1</span><span class="s1">:</span>
6098 <a name="l6078"><span class="ln">6078 </span></a>                <span class="s1">matchExpr = _FB(lastExpr + opExpr) + Group(lastExpr + OneOrMore(opExpr))</span>
6099 <a name="l6079"><span class="ln">6079 </span></a>            <span class="s3">elif </span><span class="s1">arity == </span><span class="s4">2</span><span class="s1">:</span>
6100 <a name="l6080"><span class="ln">6080 </span></a>                <span class="s3">if </span><span class="s1">opExpr </span><span class="s3">is not None</span><span class="s1">:</span>
6101 <a name="l6081"><span class="ln">6081 </span></a>                    <span class="s1">matchExpr = _FB(lastExpr + opExpr + lastExpr) + Group(lastExpr + OneOrMore(opExpr + lastExpr))</span>
6102 <a name="l6082"><span class="ln">6082 </span></a>                <span class="s3">else</span><span class="s1">:</span>
6103 <a name="l6083"><span class="ln">6083 </span></a>                    <span class="s1">matchExpr = _FB(lastExpr + lastExpr) + Group(lastExpr + OneOrMore(lastExpr))</span>
6104 <a name="l6084"><span class="ln">6084 </span></a>            <span class="s3">elif </span><span class="s1">arity == </span><span class="s4">3</span><span class="s1">:</span>
6105 <a name="l6085"><span class="ln">6085 </span></a>                <span class="s1">matchExpr = (_FB(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr)</span>
6106 <a name="l6086"><span class="ln">6086 </span></a>                             <span class="s1">+ Group(lastExpr + OneOrMore(opExpr1 + lastExpr + opExpr2 + lastExpr)))</span>
6107 <a name="l6087"><span class="ln">6087 </span></a>            <span class="s3">else</span><span class="s1">:</span>
6108 <a name="l6088"><span class="ln">6088 </span></a>                <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;operator must be unary (1), binary (2), or ternary (3)&quot;</span><span class="s1">)</span>
6109 <a name="l6089"><span class="ln">6089 </span></a>        <span class="s3">elif </span><span class="s1">rightLeftAssoc == opAssoc.RIGHT:</span>
6110 <a name="l6090"><span class="ln">6090 </span></a>            <span class="s3">if </span><span class="s1">arity == </span><span class="s4">1</span><span class="s1">:</span>
6111 <a name="l6091"><span class="ln">6091 </span></a>                <span class="s0"># try to avoid LR with this extra test</span>
6112 <a name="l6092"><span class="ln">6092 </span></a>                <span class="s3">if not </span><span class="s1">isinstance(opExpr</span><span class="s3">, </span><span class="s1">Optional):</span>
6113 <a name="l6093"><span class="ln">6093 </span></a>                    <span class="s1">opExpr = Optional(opExpr)</span>
6114 <a name="l6094"><span class="ln">6094 </span></a>                <span class="s1">matchExpr = _FB(opExpr.expr + thisExpr) + Group(opExpr + thisExpr)</span>
6115 <a name="l6095"><span class="ln">6095 </span></a>            <span class="s3">elif </span><span class="s1">arity == </span><span class="s4">2</span><span class="s1">:</span>
6116 <a name="l6096"><span class="ln">6096 </span></a>                <span class="s3">if </span><span class="s1">opExpr </span><span class="s3">is not None</span><span class="s1">:</span>
6117 <a name="l6097"><span class="ln">6097 </span></a>                    <span class="s1">matchExpr = _FB(lastExpr + opExpr + thisExpr) + Group(lastExpr + OneOrMore(opExpr + thisExpr))</span>
6118 <a name="l6098"><span class="ln">6098 </span></a>                <span class="s3">else</span><span class="s1">:</span>
6119 <a name="l6099"><span class="ln">6099 </span></a>                    <span class="s1">matchExpr = _FB(lastExpr + thisExpr) + Group(lastExpr + OneOrMore(thisExpr))</span>
6120 <a name="l6100"><span class="ln">6100 </span></a>            <span class="s3">elif </span><span class="s1">arity == </span><span class="s4">3</span><span class="s1">:</span>
6121 <a name="l6101"><span class="ln">6101 </span></a>                <span class="s1">matchExpr = (_FB(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr)</span>
6122 <a name="l6102"><span class="ln">6102 </span></a>                             <span class="s1">+ Group(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr))</span>
6123 <a name="l6103"><span class="ln">6103 </span></a>            <span class="s3">else</span><span class="s1">:</span>
6124 <a name="l6104"><span class="ln">6104 </span></a>                <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;operator must be unary (1), binary (2), or ternary (3)&quot;</span><span class="s1">)</span>
6125 <a name="l6105"><span class="ln">6105 </span></a>        <span class="s3">else</span><span class="s1">:</span>
6126 <a name="l6106"><span class="ln">6106 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;operator must indicate right or left associativity&quot;</span><span class="s1">)</span>
6127 <a name="l6107"><span class="ln">6107 </span></a>        <span class="s3">if </span><span class="s1">pa:</span>
6128 <a name="l6108"><span class="ln">6108 </span></a>            <span class="s3">if </span><span class="s1">isinstance(pa</span><span class="s3">, </span><span class="s1">(tuple</span><span class="s3">, </span><span class="s1">list)):</span>
6129 <a name="l6109"><span class="ln">6109 </span></a>                <span class="s1">matchExpr.setParseAction(*pa)</span>
6130 <a name="l6110"><span class="ln">6110 </span></a>            <span class="s3">else</span><span class="s1">:</span>
6131 <a name="l6111"><span class="ln">6111 </span></a>                <span class="s1">matchExpr.setParseAction(pa)</span>
6132 <a name="l6112"><span class="ln">6112 </span></a>        <span class="s1">thisExpr &lt;&lt;= (matchExpr.setName(termName) | lastExpr)</span>
6133 <a name="l6113"><span class="ln">6113 </span></a>        <span class="s1">lastExpr = thisExpr</span>
6134 <a name="l6114"><span class="ln">6114 </span></a>    <span class="s1">ret &lt;&lt;= lastExpr</span>
6135 <a name="l6115"><span class="ln">6115 </span></a>    <span class="s3">return </span><span class="s1">ret</span>
6136 <a name="l6116"><span class="ln">6116 </span></a>
6137 <a name="l6117"><span class="ln">6117 </span></a><span class="s1">operatorPrecedence = infixNotation</span>
6138 <a name="l6118"><span class="ln">6118 </span></a><span class="s2">&quot;&quot;&quot;(Deprecated) Former name of :class:`infixNotation`, will be 
6139 <a name="l6119"><span class="ln">6119 </span></a>dropped in a future release.&quot;&quot;&quot;</span>
6140 <a name="l6120"><span class="ln">6120 </span></a>
6141 <a name="l6121"><span class="ln">6121 </span></a><span class="s1">dblQuotedString = Combine(Regex(</span><span class="s2">r'&quot;(?:[^&quot;\n\r\\]|(?:&quot;&quot;)|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*'</span><span class="s1">) + </span><span class="s2">'&quot;'</span><span class="s1">).setName(</span><span class="s2">&quot;string enclosed in double quotes&quot;</span><span class="s1">)</span>
6142 <a name="l6122"><span class="ln">6122 </span></a><span class="s1">sglQuotedString = Combine(Regex(</span><span class="s2">r&quot;'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*&quot;</span><span class="s1">) + </span><span class="s2">&quot;'&quot;</span><span class="s1">).setName(</span><span class="s2">&quot;string enclosed in single quotes&quot;</span><span class="s1">)</span>
6143 <a name="l6123"><span class="ln">6123 </span></a><span class="s1">quotedString = Combine(Regex(</span><span class="s2">r'&quot;(?:[^&quot;\n\r\\]|(?:&quot;&quot;)|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*'</span><span class="s1">) + </span><span class="s2">'&quot;'</span>
6144 <a name="l6124"><span class="ln">6124 </span></a>                       <span class="s1">| Regex(</span><span class="s2">r&quot;'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*&quot;</span><span class="s1">) + </span><span class="s2">&quot;'&quot;</span><span class="s1">).setName(</span><span class="s2">&quot;quotedString using single or double quotes&quot;</span><span class="s1">)</span>
6145 <a name="l6125"><span class="ln">6125 </span></a><span class="s1">unicodeString = Combine(_L(</span><span class="s2">'u'</span><span class="s1">) + quotedString.copy()).setName(</span><span class="s2">&quot;unicode string literal&quot;</span><span class="s1">)</span>
6146 <a name="l6126"><span class="ln">6126 </span></a>
6147 <a name="l6127"><span class="ln">6127 </span></a><span class="s3">def </span><span class="s1">nestedExpr(opener=</span><span class="s2">&quot;(&quot;</span><span class="s3">, </span><span class="s1">closer=</span><span class="s2">&quot;)&quot;</span><span class="s3">, </span><span class="s1">content=</span><span class="s3">None, </span><span class="s1">ignoreExpr=quotedString.copy()):</span>
6148 <a name="l6128"><span class="ln">6128 </span></a>    <span class="s5">&quot;&quot;&quot;Helper method for defining nested lists enclosed in opening and 
6149 <a name="l6129"><span class="ln">6129 </span></a>    closing delimiters (&quot;(&quot; and &quot;)&quot; are the default). 
6150 <a name="l6130"><span class="ln">6130 </span></a> 
6151 <a name="l6131"><span class="ln">6131 </span></a>    Parameters: 
6152 <a name="l6132"><span class="ln">6132 </span></a>     - opener - opening character for a nested list 
6153 <a name="l6133"><span class="ln">6133 </span></a>       (default= ``&quot;(&quot;``); can also be a pyparsing expression 
6154 <a name="l6134"><span class="ln">6134 </span></a>     - closer - closing character for a nested list 
6155 <a name="l6135"><span class="ln">6135 </span></a>       (default= ``&quot;)&quot;``); can also be a pyparsing expression 
6156 <a name="l6136"><span class="ln">6136 </span></a>     - content - expression for items within the nested lists 
6157 <a name="l6137"><span class="ln">6137 </span></a>       (default= ``None``) 
6158 <a name="l6138"><span class="ln">6138 </span></a>     - ignoreExpr - expression for ignoring opening and closing 
6159 <a name="l6139"><span class="ln">6139 </span></a>       delimiters (default= :class:`quotedString`) 
6160 <a name="l6140"><span class="ln">6140 </span></a> 
6161 <a name="l6141"><span class="ln">6141 </span></a>    If an expression is not provided for the content argument, the 
6162 <a name="l6142"><span class="ln">6142 </span></a>    nested expression will capture all whitespace-delimited content 
6163 <a name="l6143"><span class="ln">6143 </span></a>    between delimiters as a list of separate values. 
6164 <a name="l6144"><span class="ln">6144 </span></a> 
6165 <a name="l6145"><span class="ln">6145 </span></a>    Use the ``ignoreExpr`` argument to define expressions that may 
6166 <a name="l6146"><span class="ln">6146 </span></a>    contain opening or closing characters that should not be treated as 
6167 <a name="l6147"><span class="ln">6147 </span></a>    opening or closing characters for nesting, such as quotedString or 
6168 <a name="l6148"><span class="ln">6148 </span></a>    a comment expression.  Specify multiple expressions using an 
6169 <a name="l6149"><span class="ln">6149 </span></a>    :class:`Or` or :class:`MatchFirst`. The default is 
6170 <a name="l6150"><span class="ln">6150 </span></a>    :class:`quotedString`, but if no expressions are to be ignored, then 
6171 <a name="l6151"><span class="ln">6151 </span></a>    pass ``None`` for this argument. 
6172 <a name="l6152"><span class="ln">6152 </span></a> 
6173 <a name="l6153"><span class="ln">6153 </span></a>    Example:: 
6174 <a name="l6154"><span class="ln">6154 </span></a> 
6175 <a name="l6155"><span class="ln">6155 </span></a>        data_type = oneOf(&quot;void int short long char float double&quot;) 
6176 <a name="l6156"><span class="ln">6156 </span></a>        decl_data_type = Combine(data_type + Optional(Word('*'))) 
6177 <a name="l6157"><span class="ln">6157 </span></a>        ident = Word(alphas+'_', alphanums+'_') 
6178 <a name="l6158"><span class="ln">6158 </span></a>        number = pyparsing_common.number 
6179 <a name="l6159"><span class="ln">6159 </span></a>        arg = Group(decl_data_type + ident) 
6180 <a name="l6160"><span class="ln">6160 </span></a>        LPAR, RPAR = map(Suppress, &quot;()&quot;) 
6181 <a name="l6161"><span class="ln">6161 </span></a> 
6182 <a name="l6162"><span class="ln">6162 </span></a>        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment)) 
6183 <a name="l6163"><span class="ln">6163 </span></a> 
6184 <a name="l6164"><span class="ln">6164 </span></a>        c_function = (decl_data_type(&quot;type&quot;) 
6185 <a name="l6165"><span class="ln">6165 </span></a>                      + ident(&quot;name&quot;) 
6186 <a name="l6166"><span class="ln">6166 </span></a>                      + LPAR + Optional(delimitedList(arg), [])(&quot;args&quot;) + RPAR 
6187 <a name="l6167"><span class="ln">6167 </span></a>                      + code_body(&quot;body&quot;)) 
6188 <a name="l6168"><span class="ln">6168 </span></a>        c_function.ignore(cStyleComment) 
6189 <a name="l6169"><span class="ln">6169 </span></a> 
6190 <a name="l6170"><span class="ln">6170 </span></a>        source_code = ''' 
6191 <a name="l6171"><span class="ln">6171 </span></a>            int is_odd(int x) { 
6192 <a name="l6172"><span class="ln">6172 </span></a>                return (x%2); 
6193 <a name="l6173"><span class="ln">6173 </span></a>            } 
6194 <a name="l6174"><span class="ln">6174 </span></a> 
6195 <a name="l6175"><span class="ln">6175 </span></a>            int dec_to_hex(char hchar) { 
6196 <a name="l6176"><span class="ln">6176 </span></a>                if (hchar &gt;= '0' &amp;&amp; hchar &lt;= '9') { 
6197 <a name="l6177"><span class="ln">6177 </span></a>                    return (ord(hchar)-ord('0')); 
6198 <a name="l6178"><span class="ln">6178 </span></a>                } else { 
6199 <a name="l6179"><span class="ln">6179 </span></a>                    return (10+ord(hchar)-ord('A')); 
6200 <a name="l6180"><span class="ln">6180 </span></a>                } 
6201 <a name="l6181"><span class="ln">6181 </span></a>            } 
6202 <a name="l6182"><span class="ln">6182 </span></a>        ''' 
6203 <a name="l6183"><span class="ln">6183 </span></a>        for func in c_function.searchString(source_code): 
6204 <a name="l6184"><span class="ln">6184 </span></a>            print(&quot;%(name)s (%(type)s) args: %(args)s&quot; % func) 
6205 <a name="l6185"><span class="ln">6185 </span></a> 
6206 <a name="l6186"><span class="ln">6186 </span></a> 
6207 <a name="l6187"><span class="ln">6187 </span></a>    prints:: 
6208 <a name="l6188"><span class="ln">6188 </span></a> 
6209 <a name="l6189"><span class="ln">6189 </span></a>        is_odd (int) args: [['int', 'x']] 
6210 <a name="l6190"><span class="ln">6190 </span></a>        dec_to_hex (int) args: [['char', 'hchar']] 
6211 <a name="l6191"><span class="ln">6191 </span></a>    &quot;&quot;&quot;</span>
6212 <a name="l6192"><span class="ln">6192 </span></a>    <span class="s3">if </span><span class="s1">opener == closer:</span>
6213 <a name="l6193"><span class="ln">6193 </span></a>        <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;opening and closing strings cannot be the same&quot;</span><span class="s1">)</span>
6214 <a name="l6194"><span class="ln">6194 </span></a>    <span class="s3">if </span><span class="s1">content </span><span class="s3">is None</span><span class="s1">:</span>
6215 <a name="l6195"><span class="ln">6195 </span></a>        <span class="s3">if </span><span class="s1">isinstance(opener</span><span class="s3">, </span><span class="s1">basestring) </span><span class="s3">and </span><span class="s1">isinstance(closer</span><span class="s3">, </span><span class="s1">basestring):</span>
6216 <a name="l6196"><span class="ln">6196 </span></a>            <span class="s3">if </span><span class="s1">len(opener) == </span><span class="s4">1 </span><span class="s3">and </span><span class="s1">len(closer) == </span><span class="s4">1</span><span class="s1">:</span>
6217 <a name="l6197"><span class="ln">6197 </span></a>                <span class="s3">if </span><span class="s1">ignoreExpr </span><span class="s3">is not None</span><span class="s1">:</span>
6218 <a name="l6198"><span class="ln">6198 </span></a>                    <span class="s1">content = (Combine(OneOrMore(~ignoreExpr</span>
6219 <a name="l6199"><span class="ln">6199 </span></a>                                                 <span class="s1">+ CharsNotIn(opener</span>
6220 <a name="l6200"><span class="ln">6200 </span></a>                                                              <span class="s1">+ closer</span>
6221 <a name="l6201"><span class="ln">6201 </span></a>                                                              <span class="s1">+ ParserElement.DEFAULT_WHITE_CHARS</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">1</span><span class="s1">)</span>
6222 <a name="l6202"><span class="ln">6202 </span></a>                                                 <span class="s1">)</span>
6223 <a name="l6203"><span class="ln">6203 </span></a>                                       <span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">].strip()))</span>
6224 <a name="l6204"><span class="ln">6204 </span></a>                <span class="s3">else</span><span class="s1">:</span>
6225 <a name="l6205"><span class="ln">6205 </span></a>                    <span class="s1">content = (empty.copy() + CharsNotIn(opener</span>
6226 <a name="l6206"><span class="ln">6206 </span></a>                                                         <span class="s1">+ closer</span>
6227 <a name="l6207"><span class="ln">6207 </span></a>                                                         <span class="s1">+ ParserElement.DEFAULT_WHITE_CHARS</span>
6228 <a name="l6208"><span class="ln">6208 </span></a>                                                         <span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">].strip()))</span>
6229 <a name="l6209"><span class="ln">6209 </span></a>            <span class="s3">else</span><span class="s1">:</span>
6230 <a name="l6210"><span class="ln">6210 </span></a>                <span class="s3">if </span><span class="s1">ignoreExpr </span><span class="s3">is not None</span><span class="s1">:</span>
6231 <a name="l6211"><span class="ln">6211 </span></a>                    <span class="s1">content = (Combine(OneOrMore(~ignoreExpr</span>
6232 <a name="l6212"><span class="ln">6212 </span></a>                                                 <span class="s1">+ ~Literal(opener)</span>
6233 <a name="l6213"><span class="ln">6213 </span></a>                                                 <span class="s1">+ ~Literal(closer)</span>
6234 <a name="l6214"><span class="ln">6214 </span></a>                                                 <span class="s1">+ CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">1</span><span class="s1">))</span>
6235 <a name="l6215"><span class="ln">6215 </span></a>                                       <span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">].strip()))</span>
6236 <a name="l6216"><span class="ln">6216 </span></a>                <span class="s3">else</span><span class="s1">:</span>
6237 <a name="l6217"><span class="ln">6217 </span></a>                    <span class="s1">content = (Combine(OneOrMore(~Literal(opener)</span>
6238 <a name="l6218"><span class="ln">6218 </span></a>                                                 <span class="s1">+ ~Literal(closer)</span>
6239 <a name="l6219"><span class="ln">6219 </span></a>                                                 <span class="s1">+ CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS</span><span class="s3">, </span><span class="s1">exact=</span><span class="s4">1</span><span class="s1">))</span>
6240 <a name="l6220"><span class="ln">6220 </span></a>                                       <span class="s1">).setParseAction(</span><span class="s3">lambda </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">].strip()))</span>
6241 <a name="l6221"><span class="ln">6221 </span></a>        <span class="s3">else</span><span class="s1">:</span>
6242 <a name="l6222"><span class="ln">6222 </span></a>            <span class="s3">raise </span><span class="s1">ValueError(</span><span class="s2">&quot;opening and closing arguments must be strings if no content expression is given&quot;</span><span class="s1">)</span>
6243 <a name="l6223"><span class="ln">6223 </span></a>    <span class="s1">ret = Forward()</span>
6244 <a name="l6224"><span class="ln">6224 </span></a>    <span class="s3">if </span><span class="s1">ignoreExpr </span><span class="s3">is not None</span><span class="s1">:</span>
6245 <a name="l6225"><span class="ln">6225 </span></a>        <span class="s1">ret &lt;&lt;= Group(Suppress(opener) + ZeroOrMore(ignoreExpr | ret | content) + Suppress(closer))</span>
6246 <a name="l6226"><span class="ln">6226 </span></a>    <span class="s3">else</span><span class="s1">:</span>
6247 <a name="l6227"><span class="ln">6227 </span></a>        <span class="s1">ret &lt;&lt;= Group(Suppress(opener) + ZeroOrMore(ret | content)  + Suppress(closer))</span>
6248 <a name="l6228"><span class="ln">6228 </span></a>    <span class="s1">ret.setName(</span><span class="s2">'nested %s%s expression' </span><span class="s1">% (opener</span><span class="s3">, </span><span class="s1">closer))</span>
6249 <a name="l6229"><span class="ln">6229 </span></a>    <span class="s3">return </span><span class="s1">ret</span>
6250 <a name="l6230"><span class="ln">6230 </span></a>
6251 <a name="l6231"><span class="ln">6231 </span></a><span class="s3">def </span><span class="s1">indentedBlock(blockStatementExpr</span><span class="s3">, </span><span class="s1">indentStack</span><span class="s3">, </span><span class="s1">indent=</span><span class="s3">True</span><span class="s1">):</span>
6252 <a name="l6232"><span class="ln">6232 </span></a>    <span class="s5">&quot;&quot;&quot;Helper method for defining space-delimited indentation blocks, 
6253 <a name="l6233"><span class="ln">6233 </span></a>    such as those used to define block statements in Python source code. 
6254 <a name="l6234"><span class="ln">6234 </span></a> 
6255 <a name="l6235"><span class="ln">6235 </span></a>    Parameters: 
6256 <a name="l6236"><span class="ln">6236 </span></a> 
6257 <a name="l6237"><span class="ln">6237 </span></a>     - blockStatementExpr - expression defining syntax of statement that 
6258 <a name="l6238"><span class="ln">6238 </span></a>       is repeated within the indented block 
6259 <a name="l6239"><span class="ln">6239 </span></a>     - indentStack - list created by caller to manage indentation stack 
6260 <a name="l6240"><span class="ln">6240 </span></a>       (multiple statementWithIndentedBlock expressions within a single 
6261 <a name="l6241"><span class="ln">6241 </span></a>       grammar should share a common indentStack) 
6262 <a name="l6242"><span class="ln">6242 </span></a>     - indent - boolean indicating whether block must be indented beyond 
6263 <a name="l6243"><span class="ln">6243 </span></a>       the current level; set to False for block of left-most 
6264 <a name="l6244"><span class="ln">6244 </span></a>       statements (default= ``True``) 
6265 <a name="l6245"><span class="ln">6245 </span></a> 
6266 <a name="l6246"><span class="ln">6246 </span></a>    A valid block must contain at least one ``blockStatement``. 
6267 <a name="l6247"><span class="ln">6247 </span></a> 
6268 <a name="l6248"><span class="ln">6248 </span></a>    Example:: 
6269 <a name="l6249"><span class="ln">6249 </span></a> 
6270 <a name="l6250"><span class="ln">6250 </span></a>        data = ''' 
6271 <a name="l6251"><span class="ln">6251 </span></a>        def A(z): 
6272 <a name="l6252"><span class="ln">6252 </span></a>          A1 
6273 <a name="l6253"><span class="ln">6253 </span></a>          B = 100 
6274 <a name="l6254"><span class="ln">6254 </span></a>          G = A2 
6275 <a name="l6255"><span class="ln">6255 </span></a>          A2 
6276 <a name="l6256"><span class="ln">6256 </span></a>          A3 
6277 <a name="l6257"><span class="ln">6257 </span></a>        B 
6278 <a name="l6258"><span class="ln">6258 </span></a>        def BB(a,b,c): 
6279 <a name="l6259"><span class="ln">6259 </span></a>          BB1 
6280 <a name="l6260"><span class="ln">6260 </span></a>          def BBA(): 
6281 <a name="l6261"><span class="ln">6261 </span></a>            bba1 
6282 <a name="l6262"><span class="ln">6262 </span></a>            bba2 
6283 <a name="l6263"><span class="ln">6263 </span></a>            bba3 
6284 <a name="l6264"><span class="ln">6264 </span></a>        C 
6285 <a name="l6265"><span class="ln">6265 </span></a>        D 
6286 <a name="l6266"><span class="ln">6266 </span></a>        def spam(x,y): 
6287 <a name="l6267"><span class="ln">6267 </span></a>             def eggs(z): 
6288 <a name="l6268"><span class="ln">6268 </span></a>                 pass 
6289 <a name="l6269"><span class="ln">6269 </span></a>        ''' 
6290 <a name="l6270"><span class="ln">6270 </span></a> 
6291 <a name="l6271"><span class="ln">6271 </span></a> 
6292 <a name="l6272"><span class="ln">6272 </span></a>        indentStack = [1] 
6293 <a name="l6273"><span class="ln">6273 </span></a>        stmt = Forward() 
6294 <a name="l6274"><span class="ln">6274 </span></a> 
6295 <a name="l6275"><span class="ln">6275 </span></a>        identifier = Word(alphas, alphanums) 
6296 <a name="l6276"><span class="ln">6276 </span></a>        funcDecl = (&quot;def&quot; + identifier + Group(&quot;(&quot; + Optional(delimitedList(identifier)) + &quot;)&quot;) + &quot;:&quot;) 
6297 <a name="l6277"><span class="ln">6277 </span></a>        func_body = indentedBlock(stmt, indentStack) 
6298 <a name="l6278"><span class="ln">6278 </span></a>        funcDef = Group(funcDecl + func_body) 
6299 <a name="l6279"><span class="ln">6279 </span></a> 
6300 <a name="l6280"><span class="ln">6280 </span></a>        rvalue = Forward() 
6301 <a name="l6281"><span class="ln">6281 </span></a>        funcCall = Group(identifier + &quot;(&quot; + Optional(delimitedList(rvalue)) + &quot;)&quot;) 
6302 <a name="l6282"><span class="ln">6282 </span></a>        rvalue &lt;&lt; (funcCall | identifier | Word(nums)) 
6303 <a name="l6283"><span class="ln">6283 </span></a>        assignment = Group(identifier + &quot;=&quot; + rvalue) 
6304 <a name="l6284"><span class="ln">6284 </span></a>        stmt &lt;&lt; (funcDef | assignment | identifier) 
6305 <a name="l6285"><span class="ln">6285 </span></a> 
6306 <a name="l6286"><span class="ln">6286 </span></a>        module_body = OneOrMore(stmt) 
6307 <a name="l6287"><span class="ln">6287 </span></a> 
6308 <a name="l6288"><span class="ln">6288 </span></a>        parseTree = module_body.parseString(data) 
6309 <a name="l6289"><span class="ln">6289 </span></a>        parseTree.pprint() 
6310 <a name="l6290"><span class="ln">6290 </span></a> 
6311 <a name="l6291"><span class="ln">6291 </span></a>    prints:: 
6312 <a name="l6292"><span class="ln">6292 </span></a> 
6313 <a name="l6293"><span class="ln">6293 </span></a>        [['def', 
6314 <a name="l6294"><span class="ln">6294 </span></a>          'A', 
6315 <a name="l6295"><span class="ln">6295 </span></a>          ['(', 'z', ')'], 
6316 <a name="l6296"><span class="ln">6296 </span></a>          ':', 
6317 <a name="l6297"><span class="ln">6297 </span></a>          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]], 
6318 <a name="l6298"><span class="ln">6298 </span></a>         'B', 
6319 <a name="l6299"><span class="ln">6299 </span></a>         ['def', 
6320 <a name="l6300"><span class="ln">6300 </span></a>          'BB', 
6321 <a name="l6301"><span class="ln">6301 </span></a>          ['(', 'a', 'b', 'c', ')'], 
6322 <a name="l6302"><span class="ln">6302 </span></a>          ':', 
6323 <a name="l6303"><span class="ln">6303 </span></a>          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]], 
6324 <a name="l6304"><span class="ln">6304 </span></a>         'C', 
6325 <a name="l6305"><span class="ln">6305 </span></a>         'D', 
6326 <a name="l6306"><span class="ln">6306 </span></a>         ['def', 
6327 <a name="l6307"><span class="ln">6307 </span></a>          'spam', 
6328 <a name="l6308"><span class="ln">6308 </span></a>          ['(', 'x', 'y', ')'], 
6329 <a name="l6309"><span class="ln">6309 </span></a>          ':', 
6330 <a name="l6310"><span class="ln">6310 </span></a>          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
6331 <a name="l6311"><span class="ln">6311 </span></a>    &quot;&quot;&quot;</span>
6332 <a name="l6312"><span class="ln">6312 </span></a>    <span class="s1">backup_stack = indentStack[:]</span>
6333 <a name="l6313"><span class="ln">6313 </span></a>
6334 <a name="l6314"><span class="ln">6314 </span></a>    <span class="s3">def </span><span class="s1">reset_stack():</span>
6335 <a name="l6315"><span class="ln">6315 </span></a>        <span class="s1">indentStack[:] = backup_stack</span>
6336 <a name="l6316"><span class="ln">6316 </span></a>
6337 <a name="l6317"><span class="ln">6317 </span></a>    <span class="s3">def </span><span class="s1">checkPeerIndent(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
6338 <a name="l6318"><span class="ln">6318 </span></a>        <span class="s3">if </span><span class="s1">l &gt;= len(s): </span><span class="s3">return</span>
6339 <a name="l6319"><span class="ln">6319 </span></a>        <span class="s1">curCol = col(l</span><span class="s3">, </span><span class="s1">s)</span>
6340 <a name="l6320"><span class="ln">6320 </span></a>        <span class="s3">if </span><span class="s1">curCol != indentStack[-</span><span class="s4">1</span><span class="s1">]:</span>
6341 <a name="l6321"><span class="ln">6321 </span></a>            <span class="s3">if </span><span class="s1">curCol &gt; indentStack[-</span><span class="s4">1</span><span class="s1">]:</span>
6342 <a name="l6322"><span class="ln">6322 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;illegal nesting&quot;</span><span class="s1">)</span>
6343 <a name="l6323"><span class="ln">6323 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;not a peer entry&quot;</span><span class="s1">)</span>
6344 <a name="l6324"><span class="ln">6324 </span></a>
6345 <a name="l6325"><span class="ln">6325 </span></a>    <span class="s3">def </span><span class="s1">checkSubIndent(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
6346 <a name="l6326"><span class="ln">6326 </span></a>        <span class="s1">curCol = col(l</span><span class="s3">, </span><span class="s1">s)</span>
6347 <a name="l6327"><span class="ln">6327 </span></a>        <span class="s3">if </span><span class="s1">curCol &gt; indentStack[-</span><span class="s4">1</span><span class="s1">]:</span>
6348 <a name="l6328"><span class="ln">6328 </span></a>            <span class="s1">indentStack.append(curCol)</span>
6349 <a name="l6329"><span class="ln">6329 </span></a>        <span class="s3">else</span><span class="s1">:</span>
6350 <a name="l6330"><span class="ln">6330 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;not a subentry&quot;</span><span class="s1">)</span>
6351 <a name="l6331"><span class="ln">6331 </span></a>
6352 <a name="l6332"><span class="ln">6332 </span></a>    <span class="s3">def </span><span class="s1">checkUnindent(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
6353 <a name="l6333"><span class="ln">6333 </span></a>        <span class="s3">if </span><span class="s1">l &gt;= len(s): </span><span class="s3">return</span>
6354 <a name="l6334"><span class="ln">6334 </span></a>        <span class="s1">curCol = col(l</span><span class="s3">, </span><span class="s1">s)</span>
6355 <a name="l6335"><span class="ln">6335 </span></a>        <span class="s3">if not</span><span class="s1">(indentStack </span><span class="s3">and </span><span class="s1">curCol </span><span class="s3">in </span><span class="s1">indentStack):</span>
6356 <a name="l6336"><span class="ln">6336 </span></a>            <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s2">&quot;not an unindent&quot;</span><span class="s1">)</span>
6357 <a name="l6337"><span class="ln">6337 </span></a>        <span class="s3">if </span><span class="s1">curCol &lt; indentStack[-</span><span class="s4">1</span><span class="s1">]:</span>
6358 <a name="l6338"><span class="ln">6338 </span></a>            <span class="s1">indentStack.pop()</span>
6359 <a name="l6339"><span class="ln">6339 </span></a>
6360 <a name="l6340"><span class="ln">6340 </span></a>    <span class="s1">NL = OneOrMore(LineEnd().setWhitespaceChars(</span><span class="s2">&quot;</span><span class="s3">\t </span><span class="s2">&quot;</span><span class="s1">).suppress()</span><span class="s3">, </span><span class="s1">stopOn=StringEnd())</span>
6361 <a name="l6341"><span class="ln">6341 </span></a>    <span class="s1">INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName(</span><span class="s2">'INDENT'</span><span class="s1">)</span>
6362 <a name="l6342"><span class="ln">6342 </span></a>    <span class="s1">PEER   = Empty().setParseAction(checkPeerIndent).setName(</span><span class="s2">''</span><span class="s1">)</span>
6363 <a name="l6343"><span class="ln">6343 </span></a>    <span class="s1">UNDENT = Empty().setParseAction(checkUnindent).setName(</span><span class="s2">'UNINDENT'</span><span class="s1">)</span>
6364 <a name="l6344"><span class="ln">6344 </span></a>    <span class="s3">if </span><span class="s1">indent:</span>
6365 <a name="l6345"><span class="ln">6345 </span></a>        <span class="s1">smExpr = Group(Optional(NL)</span>
6366 <a name="l6346"><span class="ln">6346 </span></a>                       <span class="s1">+ INDENT</span>
6367 <a name="l6347"><span class="ln">6347 </span></a>                       <span class="s1">+ OneOrMore(PEER + Group(blockStatementExpr) + Optional(NL)</span><span class="s3">, </span><span class="s1">stopOn=StringEnd())</span>
6368 <a name="l6348"><span class="ln">6348 </span></a>                       <span class="s1">+ UNDENT)</span>
6369 <a name="l6349"><span class="ln">6349 </span></a>    <span class="s3">else</span><span class="s1">:</span>
6370 <a name="l6350"><span class="ln">6350 </span></a>        <span class="s1">smExpr = Group(Optional(NL)</span>
6371 <a name="l6351"><span class="ln">6351 </span></a>                       <span class="s1">+ OneOrMore(PEER + Group(blockStatementExpr) + Optional(NL)</span><span class="s3">, </span><span class="s1">stopOn=StringEnd())</span>
6372 <a name="l6352"><span class="ln">6352 </span></a>                       <span class="s1">+ UNDENT)</span>
6373 <a name="l6353"><span class="ln">6353 </span></a>    <span class="s1">smExpr.setFailAction(</span><span class="s3">lambda </span><span class="s1">a</span><span class="s3">, </span><span class="s1">b</span><span class="s3">, </span><span class="s1">c</span><span class="s3">, </span><span class="s1">d: reset_stack())</span>
6374 <a name="l6354"><span class="ln">6354 </span></a>    <span class="s1">blockStatementExpr.ignore(_bslash + LineEnd())</span>
6375 <a name="l6355"><span class="ln">6355 </span></a>    <span class="s3">return </span><span class="s1">smExpr.setName(</span><span class="s2">'indented block'</span><span class="s1">)</span>
6376 <a name="l6356"><span class="ln">6356 </span></a>
6377 <a name="l6357"><span class="ln">6357 </span></a><span class="s1">alphas8bit = srange(</span><span class="s2">r&quot;[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]&quot;</span><span class="s1">)</span>
6378 <a name="l6358"><span class="ln">6358 </span></a><span class="s1">punc8bit = srange(</span><span class="s2">r&quot;[\0xa1-\0xbf\0xd7\0xf7]&quot;</span><span class="s1">)</span>
6379 <a name="l6359"><span class="ln">6359 </span></a>
6380 <a name="l6360"><span class="ln">6360 </span></a><span class="s1">anyOpenTag</span><span class="s3">, </span><span class="s1">anyCloseTag = makeHTMLTags(Word(alphas</span><span class="s3">, </span><span class="s1">alphanums + </span><span class="s2">&quot;_:&quot;</span><span class="s1">).setName(</span><span class="s2">'any tag'</span><span class="s1">))</span>
6381 <a name="l6361"><span class="ln">6361 </span></a><span class="s1">_htmlEntityMap = dict(zip(</span><span class="s2">&quot;gt lt amp nbsp quot apos&quot;</span><span class="s1">.split()</span><span class="s3">, </span><span class="s2">'&gt;&lt;&amp; &quot;</span><span class="s3">\'</span><span class="s2">'</span><span class="s1">))</span>
6382 <a name="l6362"><span class="ln">6362 </span></a><span class="s1">commonHTMLEntity = Regex(</span><span class="s2">'&amp;(?P&lt;entity&gt;' </span><span class="s1">+ </span><span class="s2">'|'</span><span class="s1">.join(_htmlEntityMap.keys()) +</span><span class="s2">&quot;);&quot;</span><span class="s1">).setName(</span><span class="s2">&quot;common HTML entity&quot;</span><span class="s1">)</span>
6383 <a name="l6363"><span class="ln">6363 </span></a><span class="s3">def </span><span class="s1">replaceHTMLEntity(t):</span>
6384 <a name="l6364"><span class="ln">6364 </span></a>    <span class="s5">&quot;&quot;&quot;Helper parser action to replace common HTML entities with their special characters&quot;&quot;&quot;</span>
6385 <a name="l6365"><span class="ln">6365 </span></a>    <span class="s3">return </span><span class="s1">_htmlEntityMap.get(t.entity)</span>
6386 <a name="l6366"><span class="ln">6366 </span></a>
6387 <a name="l6367"><span class="ln">6367 </span></a><span class="s0"># it's easy to get these comment structures wrong - they're very common, so may as well make them available</span>
6388 <a name="l6368"><span class="ln">6368 </span></a><span class="s1">cStyleComment = Combine(Regex(</span><span class="s2">r&quot;/\*(?:[^*]|\*(?!/))*&quot;</span><span class="s1">) + </span><span class="s2">'*/'</span><span class="s1">).setName(</span><span class="s2">&quot;C style comment&quot;</span><span class="s1">)</span>
6389 <a name="l6369"><span class="ln">6369 </span></a><span class="s2">&quot;Comment of the form ``/* ... */``&quot;</span>
6390 <a name="l6370"><span class="ln">6370 </span></a>
6391 <a name="l6371"><span class="ln">6371 </span></a><span class="s1">htmlComment = Regex(</span><span class="s2">r&quot;&lt;!--[\s\S]*?--&gt;&quot;</span><span class="s1">).setName(</span><span class="s2">&quot;HTML comment&quot;</span><span class="s1">)</span>
6392 <a name="l6372"><span class="ln">6372 </span></a><span class="s2">&quot;Comment of the form ``&lt;!-- ... --&gt;``&quot;</span>
6393 <a name="l6373"><span class="ln">6373 </span></a>
6394 <a name="l6374"><span class="ln">6374 </span></a><span class="s1">restOfLine = Regex(</span><span class="s2">r&quot;.*&quot;</span><span class="s1">).leaveWhitespace().setName(</span><span class="s2">&quot;rest of line&quot;</span><span class="s1">)</span>
6395 <a name="l6375"><span class="ln">6375 </span></a><span class="s1">dblSlashComment = Regex(</span><span class="s2">r&quot;//(?:\\\n|[^\n])*&quot;</span><span class="s1">).setName(</span><span class="s2">&quot;// comment&quot;</span><span class="s1">)</span>
6396 <a name="l6376"><span class="ln">6376 </span></a><span class="s2">&quot;Comment of the form ``// ... (to end of line)``&quot;</span>
6397 <a name="l6377"><span class="ln">6377 </span></a>
6398 <a name="l6378"><span class="ln">6378 </span></a><span class="s1">cppStyleComment = Combine(Regex(</span><span class="s2">r&quot;/\*(?:[^*]|\*(?!/))*&quot;</span><span class="s1">) + </span><span class="s2">'*/' </span><span class="s1">| dblSlashComment).setName(</span><span class="s2">&quot;C++ style comment&quot;</span><span class="s1">)</span>
6399 <a name="l6379"><span class="ln">6379 </span></a><span class="s2">&quot;Comment of either form :class:`cStyleComment` or :class:`dblSlashComment`&quot;</span>
6400 <a name="l6380"><span class="ln">6380 </span></a>
6401 <a name="l6381"><span class="ln">6381 </span></a><span class="s1">javaStyleComment = cppStyleComment</span>
6402 <a name="l6382"><span class="ln">6382 </span></a><span class="s2">&quot;Same as :class:`cppStyleComment`&quot;</span>
6403 <a name="l6383"><span class="ln">6383 </span></a>
6404 <a name="l6384"><span class="ln">6384 </span></a><span class="s1">pythonStyleComment = Regex(</span><span class="s2">r&quot;#.*&quot;</span><span class="s1">).setName(</span><span class="s2">&quot;Python style comment&quot;</span><span class="s1">)</span>
6405 <a name="l6385"><span class="ln">6385 </span></a><span class="s2">&quot;Comment of the form ``# ... (to end of line)``&quot;</span>
6406 <a name="l6386"><span class="ln">6386 </span></a>
6407 <a name="l6387"><span class="ln">6387 </span></a><span class="s1">_commasepitem = Combine(OneOrMore(Word(printables</span><span class="s3">, </span><span class="s1">excludeChars=</span><span class="s2">','</span><span class="s1">)</span>
6408 <a name="l6388"><span class="ln">6388 </span></a>                                  <span class="s1">+ Optional(Word(</span><span class="s2">&quot; </span><span class="s3">\t</span><span class="s2">&quot;</span><span class="s1">)</span>
6409 <a name="l6389"><span class="ln">6389 </span></a>                                             <span class="s1">+ ~Literal(</span><span class="s2">&quot;,&quot;</span><span class="s1">) + ~LineEnd()))).streamline().setName(</span><span class="s2">&quot;commaItem&quot;</span><span class="s1">)</span>
6410 <a name="l6390"><span class="ln">6390 </span></a><span class="s1">commaSeparatedList = delimitedList(Optional(quotedString.copy() | _commasepitem</span><span class="s3">, </span><span class="s1">default=</span><span class="s2">&quot;&quot;</span><span class="s1">)).setName(</span><span class="s2">&quot;commaSeparatedList&quot;</span><span class="s1">)</span>
6411 <a name="l6391"><span class="ln">6391 </span></a><span class="s2">&quot;&quot;&quot;(Deprecated) Predefined expression of 1 or more printable words or 
6412 <a name="l6392"><span class="ln">6392 </span></a>quoted strings, separated by commas. 
6413 <a name="l6393"><span class="ln">6393 </span></a> 
6414 <a name="l6394"><span class="ln">6394 </span></a>This expression is deprecated in favor of :class:`pyparsing_common.comma_separated_list`. 
6415 <a name="l6395"><span class="ln">6395 </span></a>&quot;&quot;&quot;</span>
6416 <a name="l6396"><span class="ln">6396 </span></a>
6417 <a name="l6397"><span class="ln">6397 </span></a><span class="s0"># some other useful expressions - using lower-case class name since we are really using this as a namespace</span>
6418 <a name="l6398"><span class="ln">6398 </span></a><span class="s3">class </span><span class="s1">pyparsing_common:</span>
6419 <a name="l6399"><span class="ln">6399 </span></a>    <span class="s5">&quot;&quot;&quot;Here are some common low-level expressions that may be useful in 
6420 <a name="l6400"><span class="ln">6400 </span></a>    jump-starting parser development: 
6421 <a name="l6401"><span class="ln">6401 </span></a> 
6422 <a name="l6402"><span class="ln">6402 </span></a>     - numeric forms (:class:`integers&lt;integer&gt;`, :class:`reals&lt;real&gt;`, 
6423 <a name="l6403"><span class="ln">6403 </span></a>       :class:`scientific notation&lt;sci_real&gt;`) 
6424 <a name="l6404"><span class="ln">6404 </span></a>     - common :class:`programming identifiers&lt;identifier&gt;` 
6425 <a name="l6405"><span class="ln">6405 </span></a>     - network addresses (:class:`MAC&lt;mac_address&gt;`, 
6426 <a name="l6406"><span class="ln">6406 </span></a>       :class:`IPv4&lt;ipv4_address&gt;`, :class:`IPv6&lt;ipv6_address&gt;`) 
6427 <a name="l6407"><span class="ln">6407 </span></a>     - ISO8601 :class:`dates&lt;iso8601_date&gt;` and 
6428 <a name="l6408"><span class="ln">6408 </span></a>       :class:`datetime&lt;iso8601_datetime&gt;` 
6429 <a name="l6409"><span class="ln">6409 </span></a>     - :class:`UUID&lt;uuid&gt;` 
6430 <a name="l6410"><span class="ln">6410 </span></a>     - :class:`comma-separated list&lt;comma_separated_list&gt;` 
6431 <a name="l6411"><span class="ln">6411 </span></a> 
6432 <a name="l6412"><span class="ln">6412 </span></a>    Parse actions: 
6433 <a name="l6413"><span class="ln">6413 </span></a> 
6434 <a name="l6414"><span class="ln">6414 </span></a>     - :class:`convertToInteger` 
6435 <a name="l6415"><span class="ln">6415 </span></a>     - :class:`convertToFloat` 
6436 <a name="l6416"><span class="ln">6416 </span></a>     - :class:`convertToDate` 
6437 <a name="l6417"><span class="ln">6417 </span></a>     - :class:`convertToDatetime` 
6438 <a name="l6418"><span class="ln">6418 </span></a>     - :class:`stripHTMLTags` 
6439 <a name="l6419"><span class="ln">6419 </span></a>     - :class:`upcaseTokens` 
6440 <a name="l6420"><span class="ln">6420 </span></a>     - :class:`downcaseTokens` 
6441 <a name="l6421"><span class="ln">6421 </span></a> 
6442 <a name="l6422"><span class="ln">6422 </span></a>    Example:: 
6443 <a name="l6423"><span class="ln">6423 </span></a> 
6444 <a name="l6424"><span class="ln">6424 </span></a>        pyparsing_common.number.runTests(''' 
6445 <a name="l6425"><span class="ln">6425 </span></a>            # any int or real number, returned as the appropriate type 
6446 <a name="l6426"><span class="ln">6426 </span></a>            100 
6447 <a name="l6427"><span class="ln">6427 </span></a>            -100 
6448 <a name="l6428"><span class="ln">6428 </span></a>            +100 
6449 <a name="l6429"><span class="ln">6429 </span></a>            3.14159 
6450 <a name="l6430"><span class="ln">6430 </span></a>            6.02e23 
6451 <a name="l6431"><span class="ln">6431 </span></a>            1e-12 
6452 <a name="l6432"><span class="ln">6432 </span></a>            ''') 
6453 <a name="l6433"><span class="ln">6433 </span></a> 
6454 <a name="l6434"><span class="ln">6434 </span></a>        pyparsing_common.fnumber.runTests(''' 
6455 <a name="l6435"><span class="ln">6435 </span></a>            # any int or real number, returned as float 
6456 <a name="l6436"><span class="ln">6436 </span></a>            100 
6457 <a name="l6437"><span class="ln">6437 </span></a>            -100 
6458 <a name="l6438"><span class="ln">6438 </span></a>            +100 
6459 <a name="l6439"><span class="ln">6439 </span></a>            3.14159 
6460 <a name="l6440"><span class="ln">6440 </span></a>            6.02e23 
6461 <a name="l6441"><span class="ln">6441 </span></a>            1e-12 
6462 <a name="l6442"><span class="ln">6442 </span></a>            ''') 
6463 <a name="l6443"><span class="ln">6443 </span></a> 
6464 <a name="l6444"><span class="ln">6444 </span></a>        pyparsing_common.hex_integer.runTests(''' 
6465 <a name="l6445"><span class="ln">6445 </span></a>            # hex numbers 
6466 <a name="l6446"><span class="ln">6446 </span></a>            100 
6467 <a name="l6447"><span class="ln">6447 </span></a>            FF 
6468 <a name="l6448"><span class="ln">6448 </span></a>            ''') 
6469 <a name="l6449"><span class="ln">6449 </span></a> 
6470 <a name="l6450"><span class="ln">6450 </span></a>        pyparsing_common.fraction.runTests(''' 
6471 <a name="l6451"><span class="ln">6451 </span></a>            # fractions 
6472 <a name="l6452"><span class="ln">6452 </span></a>            1/2 
6473 <a name="l6453"><span class="ln">6453 </span></a>            -3/4 
6474 <a name="l6454"><span class="ln">6454 </span></a>            ''') 
6475 <a name="l6455"><span class="ln">6455 </span></a> 
6476 <a name="l6456"><span class="ln">6456 </span></a>        pyparsing_common.mixed_integer.runTests(''' 
6477 <a name="l6457"><span class="ln">6457 </span></a>            # mixed fractions 
6478 <a name="l6458"><span class="ln">6458 </span></a>            1 
6479 <a name="l6459"><span class="ln">6459 </span></a>            1/2 
6480 <a name="l6460"><span class="ln">6460 </span></a>            -3/4 
6481 <a name="l6461"><span class="ln">6461 </span></a>            1-3/4 
6482 <a name="l6462"><span class="ln">6462 </span></a>            ''') 
6483 <a name="l6463"><span class="ln">6463 </span></a> 
6484 <a name="l6464"><span class="ln">6464 </span></a>        import uuid 
6485 <a name="l6465"><span class="ln">6465 </span></a>        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID)) 
6486 <a name="l6466"><span class="ln">6466 </span></a>        pyparsing_common.uuid.runTests(''' 
6487 <a name="l6467"><span class="ln">6467 </span></a>            # uuid 
6488 <a name="l6468"><span class="ln">6468 </span></a>            12345678-1234-5678-1234-567812345678 
6489 <a name="l6469"><span class="ln">6469 </span></a>            ''') 
6490 <a name="l6470"><span class="ln">6470 </span></a> 
6491 <a name="l6471"><span class="ln">6471 </span></a>    prints:: 
6492 <a name="l6472"><span class="ln">6472 </span></a> 
6493 <a name="l6473"><span class="ln">6473 </span></a>        # any int or real number, returned as the appropriate type 
6494 <a name="l6474"><span class="ln">6474 </span></a>        100 
6495 <a name="l6475"><span class="ln">6475 </span></a>        [100] 
6496 <a name="l6476"><span class="ln">6476 </span></a> 
6497 <a name="l6477"><span class="ln">6477 </span></a>        -100 
6498 <a name="l6478"><span class="ln">6478 </span></a>        [-100] 
6499 <a name="l6479"><span class="ln">6479 </span></a> 
6500 <a name="l6480"><span class="ln">6480 </span></a>        +100 
6501 <a name="l6481"><span class="ln">6481 </span></a>        [100] 
6502 <a name="l6482"><span class="ln">6482 </span></a> 
6503 <a name="l6483"><span class="ln">6483 </span></a>        3.14159 
6504 <a name="l6484"><span class="ln">6484 </span></a>        [3.14159] 
6505 <a name="l6485"><span class="ln">6485 </span></a> 
6506 <a name="l6486"><span class="ln">6486 </span></a>        6.02e23 
6507 <a name="l6487"><span class="ln">6487 </span></a>        [6.02e+23] 
6508 <a name="l6488"><span class="ln">6488 </span></a> 
6509 <a name="l6489"><span class="ln">6489 </span></a>        1e-12 
6510 <a name="l6490"><span class="ln">6490 </span></a>        [1e-12] 
6511 <a name="l6491"><span class="ln">6491 </span></a> 
6512 <a name="l6492"><span class="ln">6492 </span></a>        # any int or real number, returned as float 
6513 <a name="l6493"><span class="ln">6493 </span></a>        100 
6514 <a name="l6494"><span class="ln">6494 </span></a>        [100.0] 
6515 <a name="l6495"><span class="ln">6495 </span></a> 
6516 <a name="l6496"><span class="ln">6496 </span></a>        -100 
6517 <a name="l6497"><span class="ln">6497 </span></a>        [-100.0] 
6518 <a name="l6498"><span class="ln">6498 </span></a> 
6519 <a name="l6499"><span class="ln">6499 </span></a>        +100 
6520 <a name="l6500"><span class="ln">6500 </span></a>        [100.0] 
6521 <a name="l6501"><span class="ln">6501 </span></a> 
6522 <a name="l6502"><span class="ln">6502 </span></a>        3.14159 
6523 <a name="l6503"><span class="ln">6503 </span></a>        [3.14159] 
6524 <a name="l6504"><span class="ln">6504 </span></a> 
6525 <a name="l6505"><span class="ln">6505 </span></a>        6.02e23 
6526 <a name="l6506"><span class="ln">6506 </span></a>        [6.02e+23] 
6527 <a name="l6507"><span class="ln">6507 </span></a> 
6528 <a name="l6508"><span class="ln">6508 </span></a>        1e-12 
6529 <a name="l6509"><span class="ln">6509 </span></a>        [1e-12] 
6530 <a name="l6510"><span class="ln">6510 </span></a> 
6531 <a name="l6511"><span class="ln">6511 </span></a>        # hex numbers 
6532 <a name="l6512"><span class="ln">6512 </span></a>        100 
6533 <a name="l6513"><span class="ln">6513 </span></a>        [256] 
6534 <a name="l6514"><span class="ln">6514 </span></a> 
6535 <a name="l6515"><span class="ln">6515 </span></a>        FF 
6536 <a name="l6516"><span class="ln">6516 </span></a>        [255] 
6537 <a name="l6517"><span class="ln">6517 </span></a> 
6538 <a name="l6518"><span class="ln">6518 </span></a>        # fractions 
6539 <a name="l6519"><span class="ln">6519 </span></a>        1/2 
6540 <a name="l6520"><span class="ln">6520 </span></a>        [0.5] 
6541 <a name="l6521"><span class="ln">6521 </span></a> 
6542 <a name="l6522"><span class="ln">6522 </span></a>        -3/4 
6543 <a name="l6523"><span class="ln">6523 </span></a>        [-0.75] 
6544 <a name="l6524"><span class="ln">6524 </span></a> 
6545 <a name="l6525"><span class="ln">6525 </span></a>        # mixed fractions 
6546 <a name="l6526"><span class="ln">6526 </span></a>        1 
6547 <a name="l6527"><span class="ln">6527 </span></a>        [1] 
6548 <a name="l6528"><span class="ln">6528 </span></a> 
6549 <a name="l6529"><span class="ln">6529 </span></a>        1/2 
6550 <a name="l6530"><span class="ln">6530 </span></a>        [0.5] 
6551 <a name="l6531"><span class="ln">6531 </span></a> 
6552 <a name="l6532"><span class="ln">6532 </span></a>        -3/4 
6553 <a name="l6533"><span class="ln">6533 </span></a>        [-0.75] 
6554 <a name="l6534"><span class="ln">6534 </span></a> 
6555 <a name="l6535"><span class="ln">6535 </span></a>        1-3/4 
6556 <a name="l6536"><span class="ln">6536 </span></a>        [1.75] 
6557 <a name="l6537"><span class="ln">6537 </span></a> 
6558 <a name="l6538"><span class="ln">6538 </span></a>        # uuid 
6559 <a name="l6539"><span class="ln">6539 </span></a>        12345678-1234-5678-1234-567812345678 
6560 <a name="l6540"><span class="ln">6540 </span></a>        [UUID('12345678-1234-5678-1234-567812345678')] 
6561 <a name="l6541"><span class="ln">6541 </span></a>    &quot;&quot;&quot;</span>
6562 <a name="l6542"><span class="ln">6542 </span></a>
6563 <a name="l6543"><span class="ln">6543 </span></a>    <span class="s1">convertToInteger = tokenMap(int)</span>
6564 <a name="l6544"><span class="ln">6544 </span></a>    <span class="s2">&quot;&quot;&quot; 
6565 <a name="l6545"><span class="ln">6545 </span></a>    Parse action for converting parsed integers to Python int 
6566 <a name="l6546"><span class="ln">6546 </span></a>    &quot;&quot;&quot;</span>
6567 <a name="l6547"><span class="ln">6547 </span></a>
6568 <a name="l6548"><span class="ln">6548 </span></a>    <span class="s1">convertToFloat = tokenMap(float)</span>
6569 <a name="l6549"><span class="ln">6549 </span></a>    <span class="s2">&quot;&quot;&quot; 
6570 <a name="l6550"><span class="ln">6550 </span></a>    Parse action for converting parsed numbers to Python float 
6571 <a name="l6551"><span class="ln">6551 </span></a>    &quot;&quot;&quot;</span>
6572 <a name="l6552"><span class="ln">6552 </span></a>
6573 <a name="l6553"><span class="ln">6553 </span></a>    <span class="s1">integer = Word(nums).setName(</span><span class="s2">&quot;integer&quot;</span><span class="s1">).setParseAction(convertToInteger)</span>
6574 <a name="l6554"><span class="ln">6554 </span></a>    <span class="s2">&quot;&quot;&quot;expression that parses an unsigned integer, returns an int&quot;&quot;&quot;</span>
6575 <a name="l6555"><span class="ln">6555 </span></a>
6576 <a name="l6556"><span class="ln">6556 </span></a>    <span class="s1">hex_integer = Word(hexnums).setName(</span><span class="s2">&quot;hex integer&quot;</span><span class="s1">).setParseAction(tokenMap(int</span><span class="s3">, </span><span class="s4">16</span><span class="s1">))</span>
6577 <a name="l6557"><span class="ln">6557 </span></a>    <span class="s2">&quot;&quot;&quot;expression that parses a hexadecimal integer, returns an int&quot;&quot;&quot;</span>
6578 <a name="l6558"><span class="ln">6558 </span></a>
6579 <a name="l6559"><span class="ln">6559 </span></a>    <span class="s1">signed_integer = Regex(</span><span class="s2">r'[+-]?\d+'</span><span class="s1">).setName(</span><span class="s2">&quot;signed integer&quot;</span><span class="s1">).setParseAction(convertToInteger)</span>
6580 <a name="l6560"><span class="ln">6560 </span></a>    <span class="s2">&quot;&quot;&quot;expression that parses an integer with optional leading sign, returns an int&quot;&quot;&quot;</span>
6581 <a name="l6561"><span class="ln">6561 </span></a>
6582 <a name="l6562"><span class="ln">6562 </span></a>    <span class="s1">fraction = (signed_integer().setParseAction(convertToFloat) + </span><span class="s2">'/' </span><span class="s1">+ signed_integer().setParseAction(convertToFloat)).setName(</span><span class="s2">&quot;fraction&quot;</span><span class="s1">)</span>
6583 <a name="l6563"><span class="ln">6563 </span></a>    <span class="s2">&quot;&quot;&quot;fractional expression of an integer divided by an integer, returns a float&quot;&quot;&quot;</span>
6584 <a name="l6564"><span class="ln">6564 </span></a>    <span class="s1">fraction.addParseAction(</span><span class="s3">lambda </span><span class="s1">t: t[</span><span class="s4">0</span><span class="s1">]/t[-</span><span class="s4">1</span><span class="s1">])</span>
6585 <a name="l6565"><span class="ln">6565 </span></a>
6586 <a name="l6566"><span class="ln">6566 </span></a>    <span class="s1">mixed_integer = (fraction | signed_integer + Optional(Optional(</span><span class="s2">'-'</span><span class="s1">).suppress() + fraction)).setName(</span><span class="s2">&quot;fraction or mixed integer-fraction&quot;</span><span class="s1">)</span>
6587 <a name="l6567"><span class="ln">6567 </span></a>    <span class="s2">&quot;&quot;&quot;mixed integer of the form 'integer - fraction', with optional leading integer, returns float&quot;&quot;&quot;</span>
6588 <a name="l6568"><span class="ln">6568 </span></a>    <span class="s1">mixed_integer.addParseAction(sum)</span>
6589 <a name="l6569"><span class="ln">6569 </span></a>
6590 <a name="l6570"><span class="ln">6570 </span></a>    <span class="s1">real = Regex(</span><span class="s2">r'[+-]?(?:\d+\.\d*|\.\d+)'</span><span class="s1">).setName(</span><span class="s2">&quot;real number&quot;</span><span class="s1">).setParseAction(convertToFloat)</span>
6591 <a name="l6571"><span class="ln">6571 </span></a>    <span class="s2">&quot;&quot;&quot;expression that parses a floating point number and returns a float&quot;&quot;&quot;</span>
6592 <a name="l6572"><span class="ln">6572 </span></a>
6593 <a name="l6573"><span class="ln">6573 </span></a>    <span class="s1">sci_real = Regex(</span><span class="s2">r'[+-]?(?:\d+(?:[eE][+-]?\d+)|(?:\d+\.\d*|\.\d+)(?:[eE][+-]?\d+)?)'</span><span class="s1">).setName(</span><span class="s2">&quot;real number with scientific notation&quot;</span><span class="s1">).setParseAction(convertToFloat)</span>
6594 <a name="l6574"><span class="ln">6574 </span></a>    <span class="s2">&quot;&quot;&quot;expression that parses a floating point number with optional 
6595 <a name="l6575"><span class="ln">6575 </span></a>    scientific notation and returns a float&quot;&quot;&quot;</span>
6596 <a name="l6576"><span class="ln">6576 </span></a>
6597 <a name="l6577"><span class="ln">6577 </span></a>    <span class="s0"># streamlining this expression makes the docs nicer-looking</span>
6598 <a name="l6578"><span class="ln">6578 </span></a>    <span class="s1">number = (sci_real | real | signed_integer).streamline()</span>
6599 <a name="l6579"><span class="ln">6579 </span></a>    <span class="s2">&quot;&quot;&quot;any numeric expression, returns the corresponding Python type&quot;&quot;&quot;</span>
6600 <a name="l6580"><span class="ln">6580 </span></a>
6601 <a name="l6581"><span class="ln">6581 </span></a>    <span class="s1">fnumber = Regex(</span><span class="s2">r'[+-]?\d+\.?\d*([eE][+-]?\d+)?'</span><span class="s1">).setName(</span><span class="s2">&quot;fnumber&quot;</span><span class="s1">).setParseAction(convertToFloat)</span>
6602 <a name="l6582"><span class="ln">6582 </span></a>    <span class="s2">&quot;&quot;&quot;any int or real number, returned as float&quot;&quot;&quot;</span>
6603 <a name="l6583"><span class="ln">6583 </span></a>
6604 <a name="l6584"><span class="ln">6584 </span></a>    <span class="s1">identifier = Word(alphas + </span><span class="s2">'_'</span><span class="s3">, </span><span class="s1">alphanums + </span><span class="s2">'_'</span><span class="s1">).setName(</span><span class="s2">&quot;identifier&quot;</span><span class="s1">)</span>
6605 <a name="l6585"><span class="ln">6585 </span></a>    <span class="s2">&quot;&quot;&quot;typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')&quot;&quot;&quot;</span>
6606 <a name="l6586"><span class="ln">6586 </span></a>
6607 <a name="l6587"><span class="ln">6587 </span></a>    <span class="s1">ipv4_address = Regex(</span><span class="s2">r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}'</span><span class="s1">).setName(</span><span class="s2">&quot;IPv4 address&quot;</span><span class="s1">)</span>
6608 <a name="l6588"><span class="ln">6588 </span></a>    <span class="s2">&quot;IPv4 address (``0.0.0.0 - 255.255.255.255``)&quot;</span>
6609 <a name="l6589"><span class="ln">6589 </span></a>
6610 <a name="l6590"><span class="ln">6590 </span></a>    <span class="s1">_ipv6_part = Regex(</span><span class="s2">r'[0-9a-fA-F]{1,4}'</span><span class="s1">).setName(</span><span class="s2">&quot;hex_integer&quot;</span><span class="s1">)</span>
6611 <a name="l6591"><span class="ln">6591 </span></a>    <span class="s1">_full_ipv6_address = (_ipv6_part + (</span><span class="s2">':' </span><span class="s1">+ _ipv6_part) * </span><span class="s4">7</span><span class="s1">).setName(</span><span class="s2">&quot;full IPv6 address&quot;</span><span class="s1">)</span>
6612 <a name="l6592"><span class="ln">6592 </span></a>    <span class="s1">_short_ipv6_address = (Optional(_ipv6_part + (</span><span class="s2">':' </span><span class="s1">+ _ipv6_part) * (</span><span class="s4">0</span><span class="s3">, </span><span class="s4">6</span><span class="s1">))</span>
6613 <a name="l6593"><span class="ln">6593 </span></a>                           <span class="s1">+ </span><span class="s2">&quot;::&quot;</span>
6614 <a name="l6594"><span class="ln">6594 </span></a>                           <span class="s1">+ Optional(_ipv6_part + (</span><span class="s2">':' </span><span class="s1">+ _ipv6_part) * (</span><span class="s4">0</span><span class="s3">, </span><span class="s4">6</span><span class="s1">))</span>
6615 <a name="l6595"><span class="ln">6595 </span></a>                           <span class="s1">).setName(</span><span class="s2">&quot;short IPv6 address&quot;</span><span class="s1">)</span>
6616 <a name="l6596"><span class="ln">6596 </span></a>    <span class="s1">_short_ipv6_address.addCondition(</span><span class="s3">lambda </span><span class="s1">t: sum(</span><span class="s4">1 </span><span class="s3">for </span><span class="s1">tt </span><span class="s3">in </span><span class="s1">t </span><span class="s3">if </span><span class="s1">pyparsing_common._ipv6_part.matches(tt)) &lt; </span><span class="s4">8</span><span class="s1">)</span>
6617 <a name="l6597"><span class="ln">6597 </span></a>    <span class="s1">_mixed_ipv6_address = (</span><span class="s2">&quot;::ffff:&quot; </span><span class="s1">+ ipv4_address).setName(</span><span class="s2">&quot;mixed IPv6 address&quot;</span><span class="s1">)</span>
6618 <a name="l6598"><span class="ln">6598 </span></a>    <span class="s1">ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName(</span><span class="s2">&quot;IPv6 address&quot;</span><span class="s1">)).setName(</span><span class="s2">&quot;IPv6 address&quot;</span><span class="s1">)</span>
6619 <a name="l6599"><span class="ln">6599 </span></a>    <span class="s2">&quot;IPv6 address (long, short, or mixed form)&quot;</span>
6620 <a name="l6600"><span class="ln">6600 </span></a>
6621 <a name="l6601"><span class="ln">6601 </span></a>    <span class="s1">mac_address = Regex(</span><span class="s2">r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}'</span><span class="s1">).setName(</span><span class="s2">&quot;MAC address&quot;</span><span class="s1">)</span>
6622 <a name="l6602"><span class="ln">6602 </span></a>    <span class="s2">&quot;MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)&quot;</span>
6623 <a name="l6603"><span class="ln">6603 </span></a>
6624 <a name="l6604"><span class="ln">6604 </span></a>    <span class="s1">@staticmethod</span>
6625 <a name="l6605"><span class="ln">6605 </span></a>    <span class="s3">def </span><span class="s1">convertToDate(fmt=</span><span class="s2">&quot;%Y-%m-%d&quot;</span><span class="s1">):</span>
6626 <a name="l6606"><span class="ln">6606 </span></a>        <span class="s5">&quot;&quot;&quot; 
6627 <a name="l6607"><span class="ln">6607 </span></a>        Helper to create a parse action for converting parsed date string to Python datetime.date 
6628 <a name="l6608"><span class="ln">6608 </span></a> 
6629 <a name="l6609"><span class="ln">6609 </span></a>        Params - 
6630 <a name="l6610"><span class="ln">6610 </span></a>         - fmt - format to be passed to datetime.strptime (default= ``&quot;%Y-%m-%d&quot;``) 
6631 <a name="l6611"><span class="ln">6611 </span></a> 
6632 <a name="l6612"><span class="ln">6612 </span></a>        Example:: 
6633 <a name="l6613"><span class="ln">6613 </span></a> 
6634 <a name="l6614"><span class="ln">6614 </span></a>            date_expr = pyparsing_common.iso8601_date.copy() 
6635 <a name="l6615"><span class="ln">6615 </span></a>            date_expr.setParseAction(pyparsing_common.convertToDate()) 
6636 <a name="l6616"><span class="ln">6616 </span></a>            print(date_expr.parseString(&quot;1999-12-31&quot;)) 
6637 <a name="l6617"><span class="ln">6617 </span></a> 
6638 <a name="l6618"><span class="ln">6618 </span></a>        prints:: 
6639 <a name="l6619"><span class="ln">6619 </span></a> 
6640 <a name="l6620"><span class="ln">6620 </span></a>            [datetime.date(1999, 12, 31)] 
6641 <a name="l6621"><span class="ln">6621 </span></a>        &quot;&quot;&quot;</span>
6642 <a name="l6622"><span class="ln">6622 </span></a>        <span class="s3">def </span><span class="s1">cvt_fn(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
6643 <a name="l6623"><span class="ln">6623 </span></a>            <span class="s3">try</span><span class="s1">:</span>
6644 <a name="l6624"><span class="ln">6624 </span></a>                <span class="s3">return </span><span class="s1">datetime.strptime(t[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">fmt).date()</span>
6645 <a name="l6625"><span class="ln">6625 </span></a>            <span class="s3">except </span><span class="s1">ValueError </span><span class="s3">as </span><span class="s1">ve:</span>
6646 <a name="l6626"><span class="ln">6626 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">str(ve))</span>
6647 <a name="l6627"><span class="ln">6627 </span></a>        <span class="s3">return </span><span class="s1">cvt_fn</span>
6648 <a name="l6628"><span class="ln">6628 </span></a>
6649 <a name="l6629"><span class="ln">6629 </span></a>    <span class="s1">@staticmethod</span>
6650 <a name="l6630"><span class="ln">6630 </span></a>    <span class="s3">def </span><span class="s1">convertToDatetime(fmt=</span><span class="s2">&quot;%Y-%m-%dT%H:%M:%S.%f&quot;</span><span class="s1">):</span>
6651 <a name="l6631"><span class="ln">6631 </span></a>        <span class="s5">&quot;&quot;&quot;Helper to create a parse action for converting parsed 
6652 <a name="l6632"><span class="ln">6632 </span></a>        datetime string to Python datetime.datetime 
6653 <a name="l6633"><span class="ln">6633 </span></a> 
6654 <a name="l6634"><span class="ln">6634 </span></a>        Params - 
6655 <a name="l6635"><span class="ln">6635 </span></a>         - fmt - format to be passed to datetime.strptime (default= ``&quot;%Y-%m-%dT%H:%M:%S.%f&quot;``) 
6656 <a name="l6636"><span class="ln">6636 </span></a> 
6657 <a name="l6637"><span class="ln">6637 </span></a>        Example:: 
6658 <a name="l6638"><span class="ln">6638 </span></a> 
6659 <a name="l6639"><span class="ln">6639 </span></a>            dt_expr = pyparsing_common.iso8601_datetime.copy() 
6660 <a name="l6640"><span class="ln">6640 </span></a>            dt_expr.setParseAction(pyparsing_common.convertToDatetime()) 
6661 <a name="l6641"><span class="ln">6641 </span></a>            print(dt_expr.parseString(&quot;1999-12-31T23:59:59.999&quot;)) 
6662 <a name="l6642"><span class="ln">6642 </span></a> 
6663 <a name="l6643"><span class="ln">6643 </span></a>        prints:: 
6664 <a name="l6644"><span class="ln">6644 </span></a> 
6665 <a name="l6645"><span class="ln">6645 </span></a>            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)] 
6666 <a name="l6646"><span class="ln">6646 </span></a>        &quot;&quot;&quot;</span>
6667 <a name="l6647"><span class="ln">6647 </span></a>        <span class="s3">def </span><span class="s1">cvt_fn(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">t):</span>
6668 <a name="l6648"><span class="ln">6648 </span></a>            <span class="s3">try</span><span class="s1">:</span>
6669 <a name="l6649"><span class="ln">6649 </span></a>                <span class="s3">return </span><span class="s1">datetime.strptime(t[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">fmt)</span>
6670 <a name="l6650"><span class="ln">6650 </span></a>            <span class="s3">except </span><span class="s1">ValueError </span><span class="s3">as </span><span class="s1">ve:</span>
6671 <a name="l6651"><span class="ln">6651 </span></a>                <span class="s3">raise </span><span class="s1">ParseException(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">str(ve))</span>
6672 <a name="l6652"><span class="ln">6652 </span></a>        <span class="s3">return </span><span class="s1">cvt_fn</span>
6673 <a name="l6653"><span class="ln">6653 </span></a>
6674 <a name="l6654"><span class="ln">6654 </span></a>    <span class="s1">iso8601_date = Regex(</span><span class="s2">r'(?P&lt;year&gt;\d{4})(?:-(?P&lt;month&gt;\d\d)(?:-(?P&lt;day&gt;\d\d))?)?'</span><span class="s1">).setName(</span><span class="s2">&quot;ISO8601 date&quot;</span><span class="s1">)</span>
6675 <a name="l6655"><span class="ln">6655 </span></a>    <span class="s2">&quot;ISO8601 date (``yyyy-mm-dd``)&quot;</span>
6676 <a name="l6656"><span class="ln">6656 </span></a>
6677 <a name="l6657"><span class="ln">6657 </span></a>    <span class="s1">iso8601_datetime = Regex(</span><span class="s2">r'(?P&lt;year&gt;\d{4})-(?P&lt;month&gt;\d\d)-(?P&lt;day&gt;\d\d)[T ](?P&lt;hour&gt;\d\d):(?P&lt;minute&gt;\d\d)(:(?P&lt;second&gt;\d\d(\.\d*)?)?)?(?P&lt;tz&gt;Z|[+-]\d\d:?\d\d)?'</span><span class="s1">).setName(</span><span class="s2">&quot;ISO8601 datetime&quot;</span><span class="s1">)</span>
6678 <a name="l6658"><span class="ln">6658 </span></a>    <span class="s2">&quot;ISO8601 datetime (``yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)``) - trailing seconds, milliseconds, and timezone optional; accepts separating ``'T'`` or ``' '``&quot;</span>
6679 <a name="l6659"><span class="ln">6659 </span></a>
6680 <a name="l6660"><span class="ln">6660 </span></a>    <span class="s1">uuid = Regex(</span><span class="s2">r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}'</span><span class="s1">).setName(</span><span class="s2">&quot;UUID&quot;</span><span class="s1">)</span>
6681 <a name="l6661"><span class="ln">6661 </span></a>    <span class="s2">&quot;UUID (``xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx``)&quot;</span>
6682 <a name="l6662"><span class="ln">6662 </span></a>
6683 <a name="l6663"><span class="ln">6663 </span></a>    <span class="s1">_html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()</span>
6684 <a name="l6664"><span class="ln">6664 </span></a>    <span class="s1">@staticmethod</span>
6685 <a name="l6665"><span class="ln">6665 </span></a>    <span class="s3">def </span><span class="s1">stripHTMLTags(s</span><span class="s3">, </span><span class="s1">l</span><span class="s3">, </span><span class="s1">tokens):</span>
6686 <a name="l6666"><span class="ln">6666 </span></a>        <span class="s5">&quot;&quot;&quot;Parse action to remove HTML tags from web page HTML source 
6687 <a name="l6667"><span class="ln">6667 </span></a> 
6688 <a name="l6668"><span class="ln">6668 </span></a>        Example:: 
6689 <a name="l6669"><span class="ln">6669 </span></a> 
6690 <a name="l6670"><span class="ln">6670 </span></a>            # strip HTML links from normal text 
6691 <a name="l6671"><span class="ln">6671 </span></a>            text = '&lt;td&gt;More info at the &lt;a href=&quot;https://github.com/pyparsing/pyparsing/wiki&quot;&gt;pyparsing&lt;/a&gt; wiki page&lt;/td&gt;' 
6692 <a name="l6672"><span class="ln">6672 </span></a>            td, td_end = makeHTMLTags(&quot;TD&quot;) 
6693 <a name="l6673"><span class="ln">6673 </span></a>            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)(&quot;body&quot;) + td_end 
6694 <a name="l6674"><span class="ln">6674 </span></a>            print(table_text.parseString(text).body) 
6695 <a name="l6675"><span class="ln">6675 </span></a> 
6696 <a name="l6676"><span class="ln">6676 </span></a>        Prints:: 
6697 <a name="l6677"><span class="ln">6677 </span></a> 
6698 <a name="l6678"><span class="ln">6678 </span></a>            More info at the pyparsing wiki page 
6699 <a name="l6679"><span class="ln">6679 </span></a>        &quot;&quot;&quot;</span>
6700 <a name="l6680"><span class="ln">6680 </span></a>        <span class="s3">return </span><span class="s1">pyparsing_common._html_stripper.transformString(tokens[</span><span class="s4">0</span><span class="s1">])</span>
6701 <a name="l6681"><span class="ln">6681 </span></a>
6702 <a name="l6682"><span class="ln">6682 </span></a>    <span class="s1">_commasepitem = Combine(OneOrMore(~Literal(</span><span class="s2">&quot;,&quot;</span><span class="s1">)</span>
6703 <a name="l6683"><span class="ln">6683 </span></a>                                      <span class="s1">+ ~LineEnd()</span>
6704 <a name="l6684"><span class="ln">6684 </span></a>                                      <span class="s1">+ Word(printables</span><span class="s3">, </span><span class="s1">excludeChars=</span><span class="s2">','</span><span class="s1">)</span>
6705 <a name="l6685"><span class="ln">6685 </span></a>                                      <span class="s1">+ Optional(White(</span><span class="s2">&quot; </span><span class="s3">\t</span><span class="s2">&quot;</span><span class="s1">)))).streamline().setName(</span><span class="s2">&quot;commaItem&quot;</span><span class="s1">)</span>
6706 <a name="l6686"><span class="ln">6686 </span></a>    <span class="s1">comma_separated_list = delimitedList(Optional(quotedString.copy()</span>
6707 <a name="l6687"><span class="ln">6687 </span></a>                                                  <span class="s1">| _commasepitem</span><span class="s3">, </span><span class="s1">default=</span><span class="s2">''</span><span class="s1">)</span>
6708 <a name="l6688"><span class="ln">6688 </span></a>                                         <span class="s1">).setName(</span><span class="s2">&quot;comma separated list&quot;</span><span class="s1">)</span>
6709 <a name="l6689"><span class="ln">6689 </span></a>    <span class="s2">&quot;&quot;&quot;Predefined expression of 1 or more printable words or quoted strings, separated by commas.&quot;&quot;&quot;</span>
6710 <a name="l6690"><span class="ln">6690 </span></a>
6711 <a name="l6691"><span class="ln">6691 </span></a>    <span class="s1">upcaseTokens = staticmethod(tokenMap(</span><span class="s3">lambda </span><span class="s1">t: _ustr(t).upper()))</span>
6712 <a name="l6692"><span class="ln">6692 </span></a>    <span class="s2">&quot;&quot;&quot;Parse action to convert tokens to upper case.&quot;&quot;&quot;</span>
6713 <a name="l6693"><span class="ln">6693 </span></a>
6714 <a name="l6694"><span class="ln">6694 </span></a>    <span class="s1">downcaseTokens = staticmethod(tokenMap(</span><span class="s3">lambda </span><span class="s1">t: _ustr(t).lower()))</span>
6715 <a name="l6695"><span class="ln">6695 </span></a>    <span class="s2">&quot;&quot;&quot;Parse action to convert tokens to lower case.&quot;&quot;&quot;</span>
6716 <a name="l6696"><span class="ln">6696 </span></a>
6717 <a name="l6697"><span class="ln">6697 </span></a>
6718 <a name="l6698"><span class="ln">6698 </span></a><span class="s3">class </span><span class="s1">_lazyclassproperty(object):</span>
6719 <a name="l6699"><span class="ln">6699 </span></a>    <span class="s3">def </span><span class="s1">__init__(self</span><span class="s3">, </span><span class="s1">fn):</span>
6720 <a name="l6700"><span class="ln">6700 </span></a>        <span class="s1">self.fn = fn</span>
6721 <a name="l6701"><span class="ln">6701 </span></a>        <span class="s1">self.__doc__ = fn.__doc__</span>
6722 <a name="l6702"><span class="ln">6702 </span></a>        <span class="s1">self.__name__ = fn.__name__</span>
6723 <a name="l6703"><span class="ln">6703 </span></a>
6724 <a name="l6704"><span class="ln">6704 </span></a>    <span class="s3">def </span><span class="s1">__get__(self</span><span class="s3">, </span><span class="s1">obj</span><span class="s3">, </span><span class="s1">cls):</span>
6725 <a name="l6705"><span class="ln">6705 </span></a>        <span class="s3">if </span><span class="s1">cls </span><span class="s3">is None</span><span class="s1">:</span>
6726 <a name="l6706"><span class="ln">6706 </span></a>            <span class="s1">cls = type(obj)</span>
6727 <a name="l6707"><span class="ln">6707 </span></a>        <span class="s3">if not </span><span class="s1">hasattr(cls</span><span class="s3">, </span><span class="s2">'_intern'</span><span class="s1">) </span><span class="s3">or </span><span class="s1">any(cls._intern </span><span class="s3">is </span><span class="s1">getattr(superclass</span><span class="s3">, </span><span class="s2">'_intern'</span><span class="s3">, </span><span class="s1">[])</span>
6728 <a name="l6708"><span class="ln">6708 </span></a>                                              <span class="s3">for </span><span class="s1">superclass </span><span class="s3">in </span><span class="s1">cls.__mro__[</span><span class="s4">1</span><span class="s1">:]):</span>
6729 <a name="l6709"><span class="ln">6709 </span></a>            <span class="s1">cls._intern = {}</span>
6730 <a name="l6710"><span class="ln">6710 </span></a>        <span class="s1">attrname = self.fn.__name__</span>
6731 <a name="l6711"><span class="ln">6711 </span></a>        <span class="s3">if </span><span class="s1">attrname </span><span class="s3">not in </span><span class="s1">cls._intern:</span>
6732 <a name="l6712"><span class="ln">6712 </span></a>            <span class="s1">cls._intern[attrname] = self.fn(cls)</span>
6733 <a name="l6713"><span class="ln">6713 </span></a>        <span class="s3">return </span><span class="s1">cls._intern[attrname]</span>
6734 <a name="l6714"><span class="ln">6714 </span></a>
6735 <a name="l6715"><span class="ln">6715 </span></a>
6736 <a name="l6716"><span class="ln">6716 </span></a><span class="s3">class </span><span class="s1">unicode_set(object):</span>
6737 <a name="l6717"><span class="ln">6717 </span></a>    <span class="s5">&quot;&quot;&quot; 
6738 <a name="l6718"><span class="ln">6718 </span></a>    A set of Unicode characters, for language-specific strings for 
6739 <a name="l6719"><span class="ln">6719 </span></a>    ``alphas``, ``nums``, ``alphanums``, and ``printables``. 
6740 <a name="l6720"><span class="ln">6720 </span></a>    A unicode_set is defined by a list of ranges in the Unicode character 
6741 <a name="l6721"><span class="ln">6721 </span></a>    set, in a class attribute ``_ranges``, such as:: 
6742 <a name="l6722"><span class="ln">6722 </span></a> 
6743 <a name="l6723"><span class="ln">6723 </span></a>        _ranges = [(0x0020, 0x007e), (0x00a0, 0x00ff),] 
6744 <a name="l6724"><span class="ln">6724 </span></a> 
6745 <a name="l6725"><span class="ln">6725 </span></a>    A unicode set can also be defined using multiple inheritance of other unicode sets:: 
6746 <a name="l6726"><span class="ln">6726 </span></a> 
6747 <a name="l6727"><span class="ln">6727 </span></a>        class CJK(Chinese, Japanese, Korean): 
6748 <a name="l6728"><span class="ln">6728 </span></a>            pass 
6749 <a name="l6729"><span class="ln">6729 </span></a>    &quot;&quot;&quot;</span>
6750 <a name="l6730"><span class="ln">6730 </span></a>    <span class="s1">_ranges = []</span>
6751 <a name="l6731"><span class="ln">6731 </span></a>
6752 <a name="l6732"><span class="ln">6732 </span></a>    <span class="s1">@classmethod</span>
6753 <a name="l6733"><span class="ln">6733 </span></a>    <span class="s3">def </span><span class="s1">_get_chars_for_ranges(cls):</span>
6754 <a name="l6734"><span class="ln">6734 </span></a>        <span class="s1">ret = []</span>
6755 <a name="l6735"><span class="ln">6735 </span></a>        <span class="s3">for </span><span class="s1">cc </span><span class="s3">in </span><span class="s1">cls.__mro__:</span>
6756 <a name="l6736"><span class="ln">6736 </span></a>            <span class="s3">if </span><span class="s1">cc </span><span class="s3">is </span><span class="s1">unicode_set:</span>
6757 <a name="l6737"><span class="ln">6737 </span></a>                <span class="s3">break</span>
6758 <a name="l6738"><span class="ln">6738 </span></a>            <span class="s3">for </span><span class="s1">rr </span><span class="s3">in </span><span class="s1">cc._ranges:</span>
6759 <a name="l6739"><span class="ln">6739 </span></a>                <span class="s1">ret.extend(range(rr[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">rr[-</span><span class="s4">1</span><span class="s1">] + </span><span class="s4">1</span><span class="s1">))</span>
6760 <a name="l6740"><span class="ln">6740 </span></a>        <span class="s3">return </span><span class="s1">[unichr(c) </span><span class="s3">for </span><span class="s1">c </span><span class="s3">in </span><span class="s1">sorted(set(ret))]</span>
6761 <a name="l6741"><span class="ln">6741 </span></a>
6762 <a name="l6742"><span class="ln">6742 </span></a>    <span class="s1">@_lazyclassproperty</span>
6763 <a name="l6743"><span class="ln">6743 </span></a>    <span class="s3">def </span><span class="s1">printables(cls):</span>
6764 <a name="l6744"><span class="ln">6744 </span></a>        <span class="s5">&quot;all non-whitespace characters in this range&quot;</span>
6765 <a name="l6745"><span class="ln">6745 </span></a>        <span class="s3">return </span><span class="s2">u''</span><span class="s1">.join(filterfalse(unicode.isspace</span><span class="s3">, </span><span class="s1">cls._get_chars_for_ranges()))</span>
6766 <a name="l6746"><span class="ln">6746 </span></a>
6767 <a name="l6747"><span class="ln">6747 </span></a>    <span class="s1">@_lazyclassproperty</span>
6768 <a name="l6748"><span class="ln">6748 </span></a>    <span class="s3">def </span><span class="s1">alphas(cls):</span>
6769 <a name="l6749"><span class="ln">6749 </span></a>        <span class="s5">&quot;all alphabetic characters in this range&quot;</span>
6770 <a name="l6750"><span class="ln">6750 </span></a>        <span class="s3">return </span><span class="s2">u''</span><span class="s1">.join(filter(unicode.isalpha</span><span class="s3">, </span><span class="s1">cls._get_chars_for_ranges()))</span>
6771 <a name="l6751"><span class="ln">6751 </span></a>
6772 <a name="l6752"><span class="ln">6752 </span></a>    <span class="s1">@_lazyclassproperty</span>
6773 <a name="l6753"><span class="ln">6753 </span></a>    <span class="s3">def </span><span class="s1">nums(cls):</span>
6774 <a name="l6754"><span class="ln">6754 </span></a>        <span class="s5">&quot;all numeric digit characters in this range&quot;</span>
6775 <a name="l6755"><span class="ln">6755 </span></a>        <span class="s3">return </span><span class="s2">u''</span><span class="s1">.join(filter(unicode.isdigit</span><span class="s3">, </span><span class="s1">cls._get_chars_for_ranges()))</span>
6776 <a name="l6756"><span class="ln">6756 </span></a>
6777 <a name="l6757"><span class="ln">6757 </span></a>    <span class="s1">@_lazyclassproperty</span>
6778 <a name="l6758"><span class="ln">6758 </span></a>    <span class="s3">def </span><span class="s1">alphanums(cls):</span>
6779 <a name="l6759"><span class="ln">6759 </span></a>        <span class="s5">&quot;all alphanumeric characters in this range&quot;</span>
6780 <a name="l6760"><span class="ln">6760 </span></a>        <span class="s3">return </span><span class="s1">cls.alphas + cls.nums</span>
6781 <a name="l6761"><span class="ln">6761 </span></a>
6782 <a name="l6762"><span class="ln">6762 </span></a>
6783 <a name="l6763"><span class="ln">6763 </span></a><span class="s3">class </span><span class="s1">pyparsing_unicode(unicode_set):</span>
6784 <a name="l6764"><span class="ln">6764 </span></a>    <span class="s5">&quot;&quot;&quot; 
6785 <a name="l6765"><span class="ln">6765 </span></a>    A namespace class for defining common language unicode_sets. 
6786 <a name="l6766"><span class="ln">6766 </span></a>    &quot;&quot;&quot;</span>
6787 <a name="l6767"><span class="ln">6767 </span></a>    <span class="s1">_ranges = [(</span><span class="s4">32</span><span class="s3">, </span><span class="s1">sys.maxunicode)]</span>
6788 <a name="l6768"><span class="ln">6768 </span></a>
6789 <a name="l6769"><span class="ln">6769 </span></a>    <span class="s3">class </span><span class="s1">Latin1(unicode_set):</span>
6790 <a name="l6770"><span class="ln">6770 </span></a>        <span class="s5">&quot;Unicode set for Latin-1 Unicode Character Range&quot;</span>
6791 <a name="l6771"><span class="ln">6771 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0020</span><span class="s3">, </span><span class="s4">0x007e</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x00a0</span><span class="s3">, </span><span class="s4">0x00ff</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6792 <a name="l6772"><span class="ln">6772 </span></a>
6793 <a name="l6773"><span class="ln">6773 </span></a>    <span class="s3">class </span><span class="s1">LatinA(unicode_set):</span>
6794 <a name="l6774"><span class="ln">6774 </span></a>        <span class="s5">&quot;Unicode set for Latin-A Unicode Character Range&quot;</span>
6795 <a name="l6775"><span class="ln">6775 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0100</span><span class="s3">, </span><span class="s4">0x017f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6796 <a name="l6776"><span class="ln">6776 </span></a>
6797 <a name="l6777"><span class="ln">6777 </span></a>    <span class="s3">class </span><span class="s1">LatinB(unicode_set):</span>
6798 <a name="l6778"><span class="ln">6778 </span></a>        <span class="s5">&quot;Unicode set for Latin-B Unicode Character Range&quot;</span>
6799 <a name="l6779"><span class="ln">6779 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0180</span><span class="s3">, </span><span class="s4">0x024f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6800 <a name="l6780"><span class="ln">6780 </span></a>
6801 <a name="l6781"><span class="ln">6781 </span></a>    <span class="s3">class </span><span class="s1">Greek(unicode_set):</span>
6802 <a name="l6782"><span class="ln">6782 </span></a>        <span class="s5">&quot;Unicode set for Greek Unicode Character Ranges&quot;</span>
6803 <a name="l6783"><span class="ln">6783 </span></a>        <span class="s1">_ranges = [</span>
6804 <a name="l6784"><span class="ln">6784 </span></a>            <span class="s1">(</span><span class="s4">0x0370</span><span class="s3">, </span><span class="s4">0x03ff</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f00</span><span class="s3">, </span><span class="s4">0x1f15</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f18</span><span class="s3">, </span><span class="s4">0x1f1d</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f20</span><span class="s3">, </span><span class="s4">0x1f45</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f48</span><span class="s3">, </span><span class="s4">0x1f4d</span><span class="s1">)</span><span class="s3">,</span>
6805 <a name="l6785"><span class="ln">6785 </span></a>            <span class="s1">(</span><span class="s4">0x1f50</span><span class="s3">, </span><span class="s4">0x1f57</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f59</span><span class="s3">,</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f5b</span><span class="s3">,</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f5d</span><span class="s3">,</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f5f</span><span class="s3">, </span><span class="s4">0x1f7d</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1f80</span><span class="s3">, </span><span class="s4">0x1fb4</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1fb6</span><span class="s3">, </span><span class="s4">0x1fc4</span><span class="s1">)</span><span class="s3">,</span>
6806 <a name="l6786"><span class="ln">6786 </span></a>            <span class="s1">(</span><span class="s4">0x1fc6</span><span class="s3">, </span><span class="s4">0x1fd3</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1fd6</span><span class="s3">, </span><span class="s4">0x1fdb</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1fdd</span><span class="s3">, </span><span class="s4">0x1fef</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1ff2</span><span class="s3">, </span><span class="s4">0x1ff4</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1ff6</span><span class="s3">, </span><span class="s4">0x1ffe</span><span class="s1">)</span><span class="s3">,</span>
6807 <a name="l6787"><span class="ln">6787 </span></a>        <span class="s1">]</span>
6808 <a name="l6788"><span class="ln">6788 </span></a>
6809 <a name="l6789"><span class="ln">6789 </span></a>    <span class="s3">class </span><span class="s1">Cyrillic(unicode_set):</span>
6810 <a name="l6790"><span class="ln">6790 </span></a>        <span class="s5">&quot;Unicode set for Cyrillic Unicode Character Range&quot;</span>
6811 <a name="l6791"><span class="ln">6791 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0400</span><span class="s3">, </span><span class="s4">0x04ff</span><span class="s1">)]</span>
6812 <a name="l6792"><span class="ln">6792 </span></a>
6813 <a name="l6793"><span class="ln">6793 </span></a>    <span class="s3">class </span><span class="s1">Chinese(unicode_set):</span>
6814 <a name="l6794"><span class="ln">6794 </span></a>        <span class="s5">&quot;Unicode set for Chinese Unicode Character Range&quot;</span>
6815 <a name="l6795"><span class="ln">6795 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x4e00</span><span class="s3">, </span><span class="s4">0x9fff</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x3000</span><span class="s3">, </span><span class="s4">0x303f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6816 <a name="l6796"><span class="ln">6796 </span></a>
6817 <a name="l6797"><span class="ln">6797 </span></a>    <span class="s3">class </span><span class="s1">Japanese(unicode_set):</span>
6818 <a name="l6798"><span class="ln">6798 </span></a>        <span class="s5">&quot;Unicode set for Japanese Unicode Character Range, combining Kanji, Hiragana, and Katakana ranges&quot;</span>
6819 <a name="l6799"><span class="ln">6799 </span></a>        <span class="s1">_ranges = []</span>
6820 <a name="l6800"><span class="ln">6800 </span></a>
6821 <a name="l6801"><span class="ln">6801 </span></a>        <span class="s3">class </span><span class="s1">Kanji(unicode_set):</span>
6822 <a name="l6802"><span class="ln">6802 </span></a>            <span class="s5">&quot;Unicode set for Kanji Unicode Character Range&quot;</span>
6823 <a name="l6803"><span class="ln">6803 </span></a>            <span class="s1">_ranges = [(</span><span class="s4">0x4E00</span><span class="s3">, </span><span class="s4">0x9Fbf</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x3000</span><span class="s3">, </span><span class="s4">0x303f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6824 <a name="l6804"><span class="ln">6804 </span></a>
6825 <a name="l6805"><span class="ln">6805 </span></a>        <span class="s3">class </span><span class="s1">Hiragana(unicode_set):</span>
6826 <a name="l6806"><span class="ln">6806 </span></a>            <span class="s5">&quot;Unicode set for Hiragana Unicode Character Range&quot;</span>
6827 <a name="l6807"><span class="ln">6807 </span></a>            <span class="s1">_ranges = [(</span><span class="s4">0x3040</span><span class="s3">, </span><span class="s4">0x309f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6828 <a name="l6808"><span class="ln">6808 </span></a>
6829 <a name="l6809"><span class="ln">6809 </span></a>        <span class="s3">class </span><span class="s1">Katakana(unicode_set):</span>
6830 <a name="l6810"><span class="ln">6810 </span></a>            <span class="s5">&quot;Unicode set for Katakana  Unicode Character Range&quot;</span>
6831 <a name="l6811"><span class="ln">6811 </span></a>            <span class="s1">_ranges = [(</span><span class="s4">0x30a0</span><span class="s3">, </span><span class="s4">0x30ff</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6832 <a name="l6812"><span class="ln">6812 </span></a>
6833 <a name="l6813"><span class="ln">6813 </span></a>    <span class="s3">class </span><span class="s1">Korean(unicode_set):</span>
6834 <a name="l6814"><span class="ln">6814 </span></a>        <span class="s5">&quot;Unicode set for Korean Unicode Character Range&quot;</span>
6835 <a name="l6815"><span class="ln">6815 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0xac00</span><span class="s3">, </span><span class="s4">0xd7af</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x1100</span><span class="s3">, </span><span class="s4">0x11ff</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x3130</span><span class="s3">, </span><span class="s4">0x318f</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0xa960</span><span class="s3">, </span><span class="s4">0xa97f</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0xd7b0</span><span class="s3">, </span><span class="s4">0xd7ff</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x3000</span><span class="s3">, </span><span class="s4">0x303f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6836 <a name="l6816"><span class="ln">6816 </span></a>
6837 <a name="l6817"><span class="ln">6817 </span></a>    <span class="s3">class </span><span class="s1">CJK(Chinese</span><span class="s3">, </span><span class="s1">Japanese</span><span class="s3">, </span><span class="s1">Korean):</span>
6838 <a name="l6818"><span class="ln">6818 </span></a>        <span class="s5">&quot;Unicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character Range&quot;</span>
6839 <a name="l6819"><span class="ln">6819 </span></a>        <span class="s3">pass</span>
6840 <a name="l6820"><span class="ln">6820 </span></a>
6841 <a name="l6821"><span class="ln">6821 </span></a>    <span class="s3">class </span><span class="s1">Thai(unicode_set):</span>
6842 <a name="l6822"><span class="ln">6822 </span></a>        <span class="s5">&quot;Unicode set for Thai Unicode Character Range&quot;</span>
6843 <a name="l6823"><span class="ln">6823 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0e01</span><span class="s3">, </span><span class="s4">0x0e3a</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x0e3f</span><span class="s3">, </span><span class="s4">0x0e5b</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6844 <a name="l6824"><span class="ln">6824 </span></a>
6845 <a name="l6825"><span class="ln">6825 </span></a>    <span class="s3">class </span><span class="s1">Arabic(unicode_set):</span>
6846 <a name="l6826"><span class="ln">6826 </span></a>        <span class="s5">&quot;Unicode set for Arabic Unicode Character Range&quot;</span>
6847 <a name="l6827"><span class="ln">6827 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0600</span><span class="s3">, </span><span class="s4">0x061b</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x061e</span><span class="s3">, </span><span class="s4">0x06ff</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0x0700</span><span class="s3">, </span><span class="s4">0x077f</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6848 <a name="l6828"><span class="ln">6828 </span></a>
6849 <a name="l6829"><span class="ln">6829 </span></a>    <span class="s3">class </span><span class="s1">Hebrew(unicode_set):</span>
6850 <a name="l6830"><span class="ln">6830 </span></a>        <span class="s5">&quot;Unicode set for Hebrew Unicode Character Range&quot;</span>
6851 <a name="l6831"><span class="ln">6831 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0590</span><span class="s3">, </span><span class="s4">0x05ff</span><span class="s1">)</span><span class="s3">,</span><span class="s1">]</span>
6852 <a name="l6832"><span class="ln">6832 </span></a>
6853 <a name="l6833"><span class="ln">6833 </span></a>    <span class="s3">class </span><span class="s1">Devanagari(unicode_set):</span>
6854 <a name="l6834"><span class="ln">6834 </span></a>        <span class="s5">&quot;Unicode set for Devanagari Unicode Character Range&quot;</span>
6855 <a name="l6835"><span class="ln">6835 </span></a>        <span class="s1">_ranges = [(</span><span class="s4">0x0900</span><span class="s3">, </span><span class="s4">0x097f</span><span class="s1">)</span><span class="s3">, </span><span class="s1">(</span><span class="s4">0xa8e0</span><span class="s3">, </span><span class="s4">0xa8ff</span><span class="s1">)]</span>
6856 <a name="l6836"><span class="ln">6836 </span></a>
6857 <a name="l6837"><span class="ln">6837 </span></a><span class="s1">pyparsing_unicode.Japanese._ranges = (pyparsing_unicode.Japanese.Kanji._ranges</span>
6858 <a name="l6838"><span class="ln">6838 </span></a>                                      <span class="s1">+ pyparsing_unicode.Japanese.Hiragana._ranges</span>
6859 <a name="l6839"><span class="ln">6839 </span></a>                                      <span class="s1">+ pyparsing_unicode.Japanese.Katakana._ranges)</span>
6860 <a name="l6840"><span class="ln">6840 </span></a>
6861 <a name="l6841"><span class="ln">6841 </span></a><span class="s0"># define ranges in language character sets</span>
6862 <a name="l6842"><span class="ln">6842 </span></a><span class="s3">if </span><span class="s1">PY_3:</span>
6863 <a name="l6843"><span class="ln">6843 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;العربية&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Arabic)</span>
6864 <a name="l6844"><span class="ln">6844 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;中文&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Chinese)</span>
6865 <a name="l6845"><span class="ln">6845 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;кириллица&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Cyrillic)</span>
6866 <a name="l6846"><span class="ln">6846 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;Ελληνικά&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Greek)</span>
6867 <a name="l6847"><span class="ln">6847 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;עִברִית&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Hebrew)</span>
6868 <a name="l6848"><span class="ln">6848 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;日本語&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Japanese)</span>
6869 <a name="l6849"><span class="ln">6849 </span></a>    <span class="s1">setattr(pyparsing_unicode.Japanese</span><span class="s3">, </span><span class="s2">u&quot;漢字&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Japanese.Kanji)</span>
6870 <a name="l6850"><span class="ln">6850 </span></a>    <span class="s1">setattr(pyparsing_unicode.Japanese</span><span class="s3">, </span><span class="s2">u&quot;カタカナ&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Japanese.Katakana)</span>
6871 <a name="l6851"><span class="ln">6851 </span></a>    <span class="s1">setattr(pyparsing_unicode.Japanese</span><span class="s3">, </span><span class="s2">u&quot;ひらがな&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Japanese.Hiragana)</span>
6872 <a name="l6852"><span class="ln">6852 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;한국어&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Korean)</span>
6873 <a name="l6853"><span class="ln">6853 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;ไทย&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Thai)</span>
6874 <a name="l6854"><span class="ln">6854 </span></a>    <span class="s1">setattr(pyparsing_unicode</span><span class="s3">, </span><span class="s2">u&quot;देवनागरी&quot;</span><span class="s3">, </span><span class="s1">pyparsing_unicode.Devanagari)</span>
6875 <a name="l6855"><span class="ln">6855 </span></a>
6876 <a name="l6856"><span class="ln">6856 </span></a>
6877 <a name="l6857"><span class="ln">6857 </span></a><span class="s3">class </span><span class="s1">pyparsing_test:</span>
6878 <a name="l6858"><span class="ln">6858 </span></a>    <span class="s5">&quot;&quot;&quot; 
6879 <a name="l6859"><span class="ln">6859 </span></a>    namespace class for classes useful in writing unit tests 
6880 <a name="l6860"><span class="ln">6860 </span></a>    &quot;&quot;&quot;</span>
6881 <a name="l6861"><span class="ln">6861 </span></a>
6882 <a name="l6862"><span class="ln">6862 </span></a>    <span class="s3">class </span><span class="s1">reset_pyparsing_context:</span>
6883 <a name="l6863"><span class="ln">6863 </span></a>        <span class="s5">&quot;&quot;&quot; 
6884 <a name="l6864"><span class="ln">6864 </span></a>        Context manager to be used when writing unit tests that modify pyparsing config values: 
6885 <a name="l6865"><span class="ln">6865 </span></a>         - packrat parsing 
6886 <a name="l6866"><span class="ln">6866 </span></a>         - default whitespace characters. 
6887 <a name="l6867"><span class="ln">6867 </span></a>         - default keyword characters 
6888 <a name="l6868"><span class="ln">6868 </span></a>         - literal string auto-conversion class 
6889 <a name="l6869"><span class="ln">6869 </span></a>         - __diag__ settings 
6890 <a name="l6870"><span class="ln">6870 </span></a> 
6891 <a name="l6871"><span class="ln">6871 </span></a>        Example: 
6892 <a name="l6872"><span class="ln">6872 </span></a>            with reset_pyparsing_context(): 
6893 <a name="l6873"><span class="ln">6873 </span></a>                # test that literals used to construct a grammar are automatically suppressed 
6894 <a name="l6874"><span class="ln">6874 </span></a>                ParserElement.inlineLiteralsUsing(Suppress) 
6895 <a name="l6875"><span class="ln">6875 </span></a> 
6896 <a name="l6876"><span class="ln">6876 </span></a>                term = Word(alphas) | Word(nums) 
6897 <a name="l6877"><span class="ln">6877 </span></a>                group = Group('(' + term[...] + ')') 
6898 <a name="l6878"><span class="ln">6878 </span></a> 
6899 <a name="l6879"><span class="ln">6879 </span></a>                # assert that the '()' characters are not included in the parsed tokens 
6900 <a name="l6880"><span class="ln">6880 </span></a>                self.assertParseAndCheckLisst(group, &quot;(abc 123 def)&quot;, ['abc', '123', 'def']) 
6901 <a name="l6881"><span class="ln">6881 </span></a> 
6902 <a name="l6882"><span class="ln">6882 </span></a>            # after exiting context manager, literals are converted to Literal expressions again 
6903 <a name="l6883"><span class="ln">6883 </span></a>        &quot;&quot;&quot;</span>
6904 <a name="l6884"><span class="ln">6884 </span></a>
6905 <a name="l6885"><span class="ln">6885 </span></a>        <span class="s3">def </span><span class="s1">__init__(self):</span>
6906 <a name="l6886"><span class="ln">6886 </span></a>            <span class="s1">self._save_context = {}</span>
6907 <a name="l6887"><span class="ln">6887 </span></a>
6908 <a name="l6888"><span class="ln">6888 </span></a>        <span class="s3">def </span><span class="s1">save(self):</span>
6909 <a name="l6889"><span class="ln">6889 </span></a>            <span class="s1">self._save_context[</span><span class="s2">&quot;default_whitespace&quot;</span><span class="s1">] = ParserElement.DEFAULT_WHITE_CHARS</span>
6910 <a name="l6890"><span class="ln">6890 </span></a>            <span class="s1">self._save_context[</span><span class="s2">&quot;default_keyword_chars&quot;</span><span class="s1">] = Keyword.DEFAULT_KEYWORD_CHARS</span>
6911 <a name="l6891"><span class="ln">6891 </span></a>            <span class="s1">self._save_context[</span>
6912 <a name="l6892"><span class="ln">6892 </span></a>                <span class="s2">&quot;literal_string_class&quot;</span>
6913 <a name="l6893"><span class="ln">6893 </span></a>            <span class="s1">] = ParserElement._literalStringClass</span>
6914 <a name="l6894"><span class="ln">6894 </span></a>            <span class="s1">self._save_context[</span><span class="s2">&quot;packrat_enabled&quot;</span><span class="s1">] = ParserElement._packratEnabled</span>
6915 <a name="l6895"><span class="ln">6895 </span></a>            <span class="s1">self._save_context[</span><span class="s2">&quot;packrat_parse&quot;</span><span class="s1">] = ParserElement._parse</span>
6916 <a name="l6896"><span class="ln">6896 </span></a>            <span class="s1">self._save_context[</span><span class="s2">&quot;__diag__&quot;</span><span class="s1">] = {</span>
6917 <a name="l6897"><span class="ln">6897 </span></a>                <span class="s1">name: getattr(__diag__</span><span class="s3">, </span><span class="s1">name) </span><span class="s3">for </span><span class="s1">name </span><span class="s3">in </span><span class="s1">__diag__._all_names</span>
6918 <a name="l6898"><span class="ln">6898 </span></a>            <span class="s1">}</span>
6919 <a name="l6899"><span class="ln">6899 </span></a>            <span class="s1">self._save_context[</span><span class="s2">&quot;__compat__&quot;</span><span class="s1">] = {</span>
6920 <a name="l6900"><span class="ln">6900 </span></a>                <span class="s2">&quot;collect_all_And_tokens&quot;</span><span class="s1">: __compat__.collect_all_And_tokens</span>
6921 <a name="l6901"><span class="ln">6901 </span></a>            <span class="s1">}</span>
6922 <a name="l6902"><span class="ln">6902 </span></a>            <span class="s3">return </span><span class="s1">self</span>
6923 <a name="l6903"><span class="ln">6903 </span></a>
6924 <a name="l6904"><span class="ln">6904 </span></a>        <span class="s3">def </span><span class="s1">restore(self):</span>
6925 <a name="l6905"><span class="ln">6905 </span></a>            <span class="s0"># reset pyparsing global state</span>
6926 <a name="l6906"><span class="ln">6906 </span></a>            <span class="s3">if </span><span class="s1">(</span>
6927 <a name="l6907"><span class="ln">6907 </span></a>                <span class="s1">ParserElement.DEFAULT_WHITE_CHARS</span>
6928 <a name="l6908"><span class="ln">6908 </span></a>                <span class="s1">!= self._save_context[</span><span class="s2">&quot;default_whitespace&quot;</span><span class="s1">]</span>
6929 <a name="l6909"><span class="ln">6909 </span></a>            <span class="s1">):</span>
6930 <a name="l6910"><span class="ln">6910 </span></a>                <span class="s1">ParserElement.setDefaultWhitespaceChars(</span>
6931 <a name="l6911"><span class="ln">6911 </span></a>                    <span class="s1">self._save_context[</span><span class="s2">&quot;default_whitespace&quot;</span><span class="s1">]</span>
6932 <a name="l6912"><span class="ln">6912 </span></a>                <span class="s1">)</span>
6933 <a name="l6913"><span class="ln">6913 </span></a>            <span class="s1">Keyword.DEFAULT_KEYWORD_CHARS = self._save_context[</span><span class="s2">&quot;default_keyword_chars&quot;</span><span class="s1">]</span>
6934 <a name="l6914"><span class="ln">6914 </span></a>            <span class="s1">ParserElement.inlineLiteralsUsing(</span>
6935 <a name="l6915"><span class="ln">6915 </span></a>                <span class="s1">self._save_context[</span><span class="s2">&quot;literal_string_class&quot;</span><span class="s1">]</span>
6936 <a name="l6916"><span class="ln">6916 </span></a>            <span class="s1">)</span>
6937 <a name="l6917"><span class="ln">6917 </span></a>            <span class="s3">for </span><span class="s1">name</span><span class="s3">, </span><span class="s1">value </span><span class="s3">in </span><span class="s1">self._save_context[</span><span class="s2">&quot;__diag__&quot;</span><span class="s1">].items():</span>
6938 <a name="l6918"><span class="ln">6918 </span></a>                <span class="s1">setattr(__diag__</span><span class="s3">, </span><span class="s1">name</span><span class="s3">, </span><span class="s1">value)</span>
6939 <a name="l6919"><span class="ln">6919 </span></a>            <span class="s1">ParserElement._packratEnabled = self._save_context[</span><span class="s2">&quot;packrat_enabled&quot;</span><span class="s1">]</span>
6940 <a name="l6920"><span class="ln">6920 </span></a>            <span class="s1">ParserElement._parse = self._save_context[</span><span class="s2">&quot;packrat_parse&quot;</span><span class="s1">]</span>
6941 <a name="l6921"><span class="ln">6921 </span></a>            <span class="s1">__compat__.collect_all_And_tokens = self._save_context[</span><span class="s2">&quot;__compat__&quot;</span><span class="s1">]</span>
6942 <a name="l6922"><span class="ln">6922 </span></a>
6943 <a name="l6923"><span class="ln">6923 </span></a>        <span class="s3">def </span><span class="s1">__enter__(self):</span>
6944 <a name="l6924"><span class="ln">6924 </span></a>            <span class="s3">return </span><span class="s1">self.save()</span>
6945 <a name="l6925"><span class="ln">6925 </span></a>
6946 <a name="l6926"><span class="ln">6926 </span></a>        <span class="s3">def </span><span class="s1">__exit__(self</span><span class="s3">, </span><span class="s1">*args):</span>
6947 <a name="l6927"><span class="ln">6927 </span></a>            <span class="s3">return </span><span class="s1">self.restore()</span>
6948 <a name="l6928"><span class="ln">6928 </span></a>
6949 <a name="l6929"><span class="ln">6929 </span></a>    <span class="s3">class </span><span class="s1">TestParseResultsAsserts:</span>
6950 <a name="l6930"><span class="ln">6930 </span></a>        <span class="s5">&quot;&quot;&quot; 
6951 <a name="l6931"><span class="ln">6931 </span></a>        A mixin class to add parse results assertion methods to normal unittest.TestCase classes. 
6952 <a name="l6932"><span class="ln">6932 </span></a>        &quot;&quot;&quot;</span>
6953 <a name="l6933"><span class="ln">6933 </span></a>        <span class="s3">def </span><span class="s1">assertParseResultsEquals(</span>
6954 <a name="l6934"><span class="ln">6934 </span></a>            <span class="s1">self</span><span class="s3">, </span><span class="s1">result</span><span class="s3">, </span><span class="s1">expected_list=</span><span class="s3">None, </span><span class="s1">expected_dict=</span><span class="s3">None, </span><span class="s1">msg=</span><span class="s3">None</span>
6955 <a name="l6935"><span class="ln">6935 </span></a>        <span class="s1">):</span>
6956 <a name="l6936"><span class="ln">6936 </span></a>            <span class="s5">&quot;&quot;&quot; 
6957 <a name="l6937"><span class="ln">6937 </span></a>            Unit test assertion to compare a ParseResults object with an optional expected_list, 
6958 <a name="l6938"><span class="ln">6938 </span></a>            and compare any defined results names with an optional expected_dict. 
6959 <a name="l6939"><span class="ln">6939 </span></a>            &quot;&quot;&quot;</span>
6960 <a name="l6940"><span class="ln">6940 </span></a>            <span class="s3">if </span><span class="s1">expected_list </span><span class="s3">is not None</span><span class="s1">:</span>
6961 <a name="l6941"><span class="ln">6941 </span></a>                <span class="s1">self.assertEqual(expected_list</span><span class="s3">, </span><span class="s1">result.asList()</span><span class="s3">, </span><span class="s1">msg=msg)</span>
6962 <a name="l6942"><span class="ln">6942 </span></a>            <span class="s3">if </span><span class="s1">expected_dict </span><span class="s3">is not None</span><span class="s1">:</span>
6963 <a name="l6943"><span class="ln">6943 </span></a>                <span class="s1">self.assertEqual(expected_dict</span><span class="s3">, </span><span class="s1">result.asDict()</span><span class="s3">, </span><span class="s1">msg=msg)</span>
6964 <a name="l6944"><span class="ln">6944 </span></a>
6965 <a name="l6945"><span class="ln">6945 </span></a>        <span class="s3">def </span><span class="s1">assertParseAndCheckList(</span>
6966 <a name="l6946"><span class="ln">6946 </span></a>            <span class="s1">self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">test_string</span><span class="s3">, </span><span class="s1">expected_list</span><span class="s3">, </span><span class="s1">msg=</span><span class="s3">None, </span><span class="s1">verbose=</span><span class="s3">True</span>
6967 <a name="l6947"><span class="ln">6947 </span></a>        <span class="s1">):</span>
6968 <a name="l6948"><span class="ln">6948 </span></a>            <span class="s5">&quot;&quot;&quot; 
6969 <a name="l6949"><span class="ln">6949 </span></a>            Convenience wrapper assert to test a parser element and input string, and assert that 
6970 <a name="l6950"><span class="ln">6950 </span></a>            the resulting ParseResults.asList() is equal to the expected_list. 
6971 <a name="l6951"><span class="ln">6951 </span></a>            &quot;&quot;&quot;</span>
6972 <a name="l6952"><span class="ln">6952 </span></a>            <span class="s1">result = expr.parseString(test_string</span><span class="s3">, </span><span class="s1">parseAll=</span><span class="s3">True</span><span class="s1">)</span>
6973 <a name="l6953"><span class="ln">6953 </span></a>            <span class="s3">if </span><span class="s1">verbose:</span>
6974 <a name="l6954"><span class="ln">6954 </span></a>                <span class="s1">print(result.dump())</span>
6975 <a name="l6955"><span class="ln">6955 </span></a>            <span class="s1">self.assertParseResultsEquals(result</span><span class="s3">, </span><span class="s1">expected_list=expected_list</span><span class="s3">, </span><span class="s1">msg=msg)</span>
6976 <a name="l6956"><span class="ln">6956 </span></a>
6977 <a name="l6957"><span class="ln">6957 </span></a>        <span class="s3">def </span><span class="s1">assertParseAndCheckDict(</span>
6978 <a name="l6958"><span class="ln">6958 </span></a>            <span class="s1">self</span><span class="s3">, </span><span class="s1">expr</span><span class="s3">, </span><span class="s1">test_string</span><span class="s3">, </span><span class="s1">expected_dict</span><span class="s3">, </span><span class="s1">msg=</span><span class="s3">None, </span><span class="s1">verbose=</span><span class="s3">True</span>
6979 <a name="l6959"><span class="ln">6959 </span></a>        <span class="s1">):</span>
6980 <a name="l6960"><span class="ln">6960 </span></a>            <span class="s5">&quot;&quot;&quot; 
6981 <a name="l6961"><span class="ln">6961 </span></a>            Convenience wrapper assert to test a parser element and input string, and assert that 
6982 <a name="l6962"><span class="ln">6962 </span></a>            the resulting ParseResults.asDict() is equal to the expected_dict. 
6983 <a name="l6963"><span class="ln">6963 </span></a>            &quot;&quot;&quot;</span>
6984 <a name="l6964"><span class="ln">6964 </span></a>            <span class="s1">result = expr.parseString(test_string</span><span class="s3">, </span><span class="s1">parseAll=</span><span class="s3">True</span><span class="s1">)</span>
6985 <a name="l6965"><span class="ln">6965 </span></a>            <span class="s3">if </span><span class="s1">verbose:</span>
6986 <a name="l6966"><span class="ln">6966 </span></a>                <span class="s1">print(result.dump())</span>
6987 <a name="l6967"><span class="ln">6967 </span></a>            <span class="s1">self.assertParseResultsEquals(result</span><span class="s3">, </span><span class="s1">expected_dict=expected_dict</span><span class="s3">, </span><span class="s1">msg=msg)</span>
6988 <a name="l6968"><span class="ln">6968 </span></a>
6989 <a name="l6969"><span class="ln">6969 </span></a>        <span class="s3">def </span><span class="s1">assertRunTestResults(</span>
6990 <a name="l6970"><span class="ln">6970 </span></a>            <span class="s1">self</span><span class="s3">, </span><span class="s1">run_tests_report</span><span class="s3">, </span><span class="s1">expected_parse_results=</span><span class="s3">None, </span><span class="s1">msg=</span><span class="s3">None</span>
6991 <a name="l6971"><span class="ln">6971 </span></a>        <span class="s1">):</span>
6992 <a name="l6972"><span class="ln">6972 </span></a>            <span class="s5">&quot;&quot;&quot; 
6993 <a name="l6973"><span class="ln">6973 </span></a>            Unit test assertion to evaluate output of ParserElement.runTests(). If a list of 
6994 <a name="l6974"><span class="ln">6974 </span></a>            list-dict tuples is given as the expected_parse_results argument, then these are zipped 
6995 <a name="l6975"><span class="ln">6975 </span></a>            with the report tuples returned by runTests and evaluated using assertParseResultsEquals. 
6996 <a name="l6976"><span class="ln">6976 </span></a>            Finally, asserts that the overall runTests() success value is True. 
6997 <a name="l6977"><span class="ln">6977 </span></a> 
6998 <a name="l6978"><span class="ln">6978 </span></a>            :param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests 
6999 <a name="l6979"><span class="ln">6979 </span></a>            :param expected_parse_results (optional): [tuple(str, list, dict, Exception)] 
7000 <a name="l6980"><span class="ln">6980 </span></a>            &quot;&quot;&quot;</span>
7001 <a name="l6981"><span class="ln">6981 </span></a>            <span class="s1">run_test_success</span><span class="s3">, </span><span class="s1">run_test_results = run_tests_report</span>
7002 <a name="l6982"><span class="ln">6982 </span></a>
7003 <a name="l6983"><span class="ln">6983 </span></a>            <span class="s3">if </span><span class="s1">expected_parse_results </span><span class="s3">is not None</span><span class="s1">:</span>
7004 <a name="l6984"><span class="ln">6984 </span></a>                <span class="s1">merged = [</span>
7005 <a name="l6985"><span class="ln">6985 </span></a>                    <span class="s1">(rpt[</span><span class="s4">0</span><span class="s1">]</span><span class="s3">, </span><span class="s1">rpt[</span><span class="s4">1</span><span class="s1">]</span><span class="s3">, </span><span class="s1">expected)</span>
7006 <a name="l6986"><span class="ln">6986 </span></a>                    <span class="s3">for </span><span class="s1">rpt</span><span class="s3">, </span><span class="s1">expected </span><span class="s3">in </span><span class="s1">zip(run_test_results</span><span class="s3">, </span><span class="s1">expected_parse_results)</span>
7007 <a name="l6987"><span class="ln">6987 </span></a>                <span class="s1">]</span>
7008 <a name="l6988"><span class="ln">6988 </span></a>                <span class="s3">for </span><span class="s1">test_string</span><span class="s3">, </span><span class="s1">result</span><span class="s3">, </span><span class="s1">expected </span><span class="s3">in </span><span class="s1">merged:</span>
7009 <a name="l6989"><span class="ln">6989 </span></a>                    <span class="s0"># expected should be a tuple containing a list and/or a dict or an exception,</span>
7010 <a name="l6990"><span class="ln">6990 </span></a>                    <span class="s0"># and optional failure message string</span>
7011 <a name="l6991"><span class="ln">6991 </span></a>                    <span class="s0"># an empty tuple will skip any result validation</span>
7012 <a name="l6992"><span class="ln">6992 </span></a>                    <span class="s1">fail_msg = next(</span>
7013 <a name="l6993"><span class="ln">6993 </span></a>                        <span class="s1">(exp </span><span class="s3">for </span><span class="s1">exp </span><span class="s3">in </span><span class="s1">expected </span><span class="s3">if </span><span class="s1">isinstance(exp</span><span class="s3">, </span><span class="s1">str))</span><span class="s3">, None</span>
7014 <a name="l6994"><span class="ln">6994 </span></a>                    <span class="s1">)</span>
7015 <a name="l6995"><span class="ln">6995 </span></a>                    <span class="s1">expected_exception = next(</span>
7016 <a name="l6996"><span class="ln">6996 </span></a>                        <span class="s1">(</span>
7017 <a name="l6997"><span class="ln">6997 </span></a>                            <span class="s1">exp</span>
7018 <a name="l6998"><span class="ln">6998 </span></a>                            <span class="s3">for </span><span class="s1">exp </span><span class="s3">in </span><span class="s1">expected</span>
7019 <a name="l6999"><span class="ln">6999 </span></a>                            <span class="s3">if </span><span class="s1">isinstance(exp</span><span class="s3">, </span><span class="s1">type) </span><span class="s3">and </span><span class="s1">issubclass(exp</span><span class="s3">, </span><span class="s1">Exception)</span>
7020 <a name="l7000"><span class="ln">7000 </span></a>                        <span class="s1">)</span><span class="s3">,</span>
7021 <a name="l7001"><span class="ln">7001 </span></a>                        <span class="s3">None,</span>
7022 <a name="l7002"><span class="ln">7002 </span></a>                    <span class="s1">)</span>
7023 <a name="l7003"><span class="ln">7003 </span></a>                    <span class="s3">if </span><span class="s1">expected_exception </span><span class="s3">is not None</span><span class="s1">:</span>
7024 <a name="l7004"><span class="ln">7004 </span></a>                        <span class="s3">with </span><span class="s1">self.assertRaises(</span>
7025 <a name="l7005"><span class="ln">7005 </span></a>                            <span class="s1">expected_exception=expected_exception</span><span class="s3">, </span><span class="s1">msg=fail_msg </span><span class="s3">or </span><span class="s1">msg</span>
7026 <a name="l7006"><span class="ln">7006 </span></a>                        <span class="s1">):</span>
7027 <a name="l7007"><span class="ln">7007 </span></a>                            <span class="s3">if </span><span class="s1">isinstance(result</span><span class="s3">, </span><span class="s1">Exception):</span>
7028 <a name="l7008"><span class="ln">7008 </span></a>                                <span class="s3">raise </span><span class="s1">result</span>
7029 <a name="l7009"><span class="ln">7009 </span></a>                    <span class="s3">else</span><span class="s1">:</span>
7030 <a name="l7010"><span class="ln">7010 </span></a>                        <span class="s1">expected_list = next(</span>
7031 <a name="l7011"><span class="ln">7011 </span></a>                            <span class="s1">(exp </span><span class="s3">for </span><span class="s1">exp </span><span class="s3">in </span><span class="s1">expected </span><span class="s3">if </span><span class="s1">isinstance(exp</span><span class="s3">, </span><span class="s1">list))</span><span class="s3">, None</span>
7032 <a name="l7012"><span class="ln">7012 </span></a>                        <span class="s1">)</span>
7033 <a name="l7013"><span class="ln">7013 </span></a>                        <span class="s1">expected_dict = next(</span>
7034 <a name="l7014"><span class="ln">7014 </span></a>                            <span class="s1">(exp </span><span class="s3">for </span><span class="s1">exp </span><span class="s3">in </span><span class="s1">expected </span><span class="s3">if </span><span class="s1">isinstance(exp</span><span class="s3">, </span><span class="s1">dict))</span><span class="s3">, None</span>
7035 <a name="l7015"><span class="ln">7015 </span></a>                        <span class="s1">)</span>
7036 <a name="l7016"><span class="ln">7016 </span></a>                        <span class="s3">if </span><span class="s1">(expected_list</span><span class="s3">, </span><span class="s1">expected_dict) != (</span><span class="s3">None, None</span><span class="s1">):</span>
7037 <a name="l7017"><span class="ln">7017 </span></a>                            <span class="s1">self.assertParseResultsEquals(</span>
7038 <a name="l7018"><span class="ln">7018 </span></a>                                <span class="s1">result</span><span class="s3">,</span>
7039 <a name="l7019"><span class="ln">7019 </span></a>                                <span class="s1">expected_list=expected_list</span><span class="s3">,</span>
7040 <a name="l7020"><span class="ln">7020 </span></a>                                <span class="s1">expected_dict=expected_dict</span><span class="s3">,</span>
7041 <a name="l7021"><span class="ln">7021 </span></a>                                <span class="s1">msg=fail_msg </span><span class="s3">or </span><span class="s1">msg</span><span class="s3">,</span>
7042 <a name="l7022"><span class="ln">7022 </span></a>                            <span class="s1">)</span>
7043 <a name="l7023"><span class="ln">7023 </span></a>                        <span class="s3">else</span><span class="s1">:</span>
7044 <a name="l7024"><span class="ln">7024 </span></a>                            <span class="s0"># warning here maybe?</span>
7045 <a name="l7025"><span class="ln">7025 </span></a>                            <span class="s1">print(</span><span class="s2">&quot;no validation for {!r}&quot;</span><span class="s1">.format(test_string))</span>
7046 <a name="l7026"><span class="ln">7026 </span></a>
7047 <a name="l7027"><span class="ln">7027 </span></a>            <span class="s0"># do this last, in case some specific test results can be reported instead</span>
7048 <a name="l7028"><span class="ln">7028 </span></a>            <span class="s1">self.assertTrue(</span>
7049 <a name="l7029"><span class="ln">7029 </span></a>                <span class="s1">run_test_success</span><span class="s3">, </span><span class="s1">msg=msg </span><span class="s3">if </span><span class="s1">msg </span><span class="s3">is not None else </span><span class="s2">&quot;failed runTests&quot;</span>
7050 <a name="l7030"><span class="ln">7030 </span></a>            <span class="s1">)</span>
7051 <a name="l7031"><span class="ln">7031 </span></a>
7052 <a name="l7032"><span class="ln">7032 </span></a>        <span class="s1">@contextmanager</span>
7053 <a name="l7033"><span class="ln">7033 </span></a>        <span class="s3">def </span><span class="s1">assertRaisesParseException(self</span><span class="s3">, </span><span class="s1">exc_type=ParseException</span><span class="s3">, </span><span class="s1">msg=</span><span class="s3">None</span><span class="s1">):</span>
7054 <a name="l7034"><span class="ln">7034 </span></a>            <span class="s3">with </span><span class="s1">self.assertRaises(exc_type</span><span class="s3">, </span><span class="s1">msg=msg):</span>
7055 <a name="l7035"><span class="ln">7035 </span></a>                <span class="s3">yield</span>
7056 <a name="l7036"><span class="ln">7036 </span></a>
7057 <a name="l7037"><span class="ln">7037 </span></a>
7058 <a name="l7038"><span class="ln">7038 </span></a><span class="s3">if </span><span class="s1">__name__ == </span><span class="s2">&quot;__main__&quot;</span><span class="s1">:</span>
7059 <a name="l7039"><span class="ln">7039 </span></a>
7060 <a name="l7040"><span class="ln">7040 </span></a>    <span class="s1">selectToken    = CaselessLiteral(</span><span class="s2">&quot;select&quot;</span><span class="s1">)</span>
7061 <a name="l7041"><span class="ln">7041 </span></a>    <span class="s1">fromToken      = CaselessLiteral(</span><span class="s2">&quot;from&quot;</span><span class="s1">)</span>
7062 <a name="l7042"><span class="ln">7042 </span></a>
7063 <a name="l7043"><span class="ln">7043 </span></a>    <span class="s1">ident          = Word(alphas</span><span class="s3">, </span><span class="s1">alphanums + </span><span class="s2">&quot;_$&quot;</span><span class="s1">)</span>
7064 <a name="l7044"><span class="ln">7044 </span></a>
7065 <a name="l7045"><span class="ln">7045 </span></a>    <span class="s1">columnName     = delimitedList(ident</span><span class="s3">, </span><span class="s2">&quot;.&quot;</span><span class="s3">, </span><span class="s1">combine=</span><span class="s3">True</span><span class="s1">).setParseAction(upcaseTokens)</span>
7066 <a name="l7046"><span class="ln">7046 </span></a>    <span class="s1">columnNameList = Group(delimitedList(columnName)).setName(</span><span class="s2">&quot;columns&quot;</span><span class="s1">)</span>
7067 <a name="l7047"><span class="ln">7047 </span></a>    <span class="s1">columnSpec     = (</span><span class="s2">'*' </span><span class="s1">| columnNameList)</span>
7068 <a name="l7048"><span class="ln">7048 </span></a>
7069 <a name="l7049"><span class="ln">7049 </span></a>    <span class="s1">tableName      = delimitedList(ident</span><span class="s3">, </span><span class="s2">&quot;.&quot;</span><span class="s3">, </span><span class="s1">combine=</span><span class="s3">True</span><span class="s1">).setParseAction(upcaseTokens)</span>
7070 <a name="l7050"><span class="ln">7050 </span></a>    <span class="s1">tableNameList  = Group(delimitedList(tableName)).setName(</span><span class="s2">&quot;tables&quot;</span><span class="s1">)</span>
7071 <a name="l7051"><span class="ln">7051 </span></a>
7072 <a name="l7052"><span class="ln">7052 </span></a>    <span class="s1">simpleSQL      = selectToken(</span><span class="s2">&quot;command&quot;</span><span class="s1">) + columnSpec(</span><span class="s2">&quot;columns&quot;</span><span class="s1">) + fromToken + tableNameList(</span><span class="s2">&quot;tables&quot;</span><span class="s1">)</span>
7073 <a name="l7053"><span class="ln">7053 </span></a>
7074 <a name="l7054"><span class="ln">7054 </span></a>    <span class="s0"># demo runTests method, including embedded comments in test string</span>
7075 <a name="l7055"><span class="ln">7055 </span></a>    <span class="s1">simpleSQL.runTests(</span><span class="s2">&quot;&quot;&quot; 
7076 <a name="l7056"><span class="ln">7056 </span></a>        # '*' as column list and dotted table name 
7077 <a name="l7057"><span class="ln">7057 </span></a>        select * from SYS.XYZZY 
7078 <a name="l7058"><span class="ln">7058 </span></a> 
7079 <a name="l7059"><span class="ln">7059 </span></a>        # caseless match on &quot;SELECT&quot;, and casts back to &quot;select&quot; 
7080 <a name="l7060"><span class="ln">7060 </span></a>        SELECT * from XYZZY, ABC 
7081 <a name="l7061"><span class="ln">7061 </span></a> 
7082 <a name="l7062"><span class="ln">7062 </span></a>        # list of column names, and mixed case SELECT keyword 
7083 <a name="l7063"><span class="ln">7063 </span></a>        Select AA,BB,CC from Sys.dual 
7084 <a name="l7064"><span class="ln">7064 </span></a> 
7085 <a name="l7065"><span class="ln">7065 </span></a>        # multiple tables 
7086 <a name="l7066"><span class="ln">7066 </span></a>        Select A, B, C from Sys.dual, Table2 
7087 <a name="l7067"><span class="ln">7067 </span></a> 
7088 <a name="l7068"><span class="ln">7068 </span></a>        # invalid SELECT keyword - should fail 
7089 <a name="l7069"><span class="ln">7069 </span></a>        Xelect A, B, C from Sys.dual 
7090 <a name="l7070"><span class="ln">7070 </span></a> 
7091 <a name="l7071"><span class="ln">7071 </span></a>        # incomplete command - should fail 
7092 <a name="l7072"><span class="ln">7072 </span></a>        Select 
7093 <a name="l7073"><span class="ln">7073 </span></a> 
7094 <a name="l7074"><span class="ln">7074 </span></a>        # invalid column name - should fail 
7095 <a name="l7075"><span class="ln">7075 </span></a>        Select ^^^ frox Sys.dual 
7096 <a name="l7076"><span class="ln">7076 </span></a> 
7097 <a name="l7077"><span class="ln">7077 </span></a>        &quot;&quot;&quot;</span><span class="s1">)</span>
7098 <a name="l7078"><span class="ln">7078 </span></a>
7099 <a name="l7079"><span class="ln">7079 </span></a>    <span class="s1">pyparsing_common.number.runTests(</span><span class="s2">&quot;&quot;&quot; 
7100 <a name="l7080"><span class="ln">7080 </span></a>        100 
7101 <a name="l7081"><span class="ln">7081 </span></a>        -100 
7102 <a name="l7082"><span class="ln">7082 </span></a>        +100 
7103 <a name="l7083"><span class="ln">7083 </span></a>        3.14159 
7104 <a name="l7084"><span class="ln">7084 </span></a>        6.02e23 
7105 <a name="l7085"><span class="ln">7085 </span></a>        1e-12 
7106 <a name="l7086"><span class="ln">7086 </span></a>        &quot;&quot;&quot;</span><span class="s1">)</span>
7107 <a name="l7087"><span class="ln">7087 </span></a>
7108 <a name="l7088"><span class="ln">7088 </span></a>    <span class="s0"># any int or real number, returned as float</span>
7109 <a name="l7089"><span class="ln">7089 </span></a>    <span class="s1">pyparsing_common.fnumber.runTests(</span><span class="s2">&quot;&quot;&quot; 
7110 <a name="l7090"><span class="ln">7090 </span></a>        100 
7111 <a name="l7091"><span class="ln">7091 </span></a>        -100 
7112 <a name="l7092"><span class="ln">7092 </span></a>        +100 
7113 <a name="l7093"><span class="ln">7093 </span></a>        3.14159 
7114 <a name="l7094"><span class="ln">7094 </span></a>        6.02e23 
7115 <a name="l7095"><span class="ln">7095 </span></a>        1e-12 
7116 <a name="l7096"><span class="ln">7096 </span></a>        &quot;&quot;&quot;</span><span class="s1">)</span>
7117 <a name="l7097"><span class="ln">7097 </span></a>
7118 <a name="l7098"><span class="ln">7098 </span></a>    <span class="s1">pyparsing_common.hex_integer.runTests(</span><span class="s2">&quot;&quot;&quot; 
7119 <a name="l7099"><span class="ln">7099 </span></a>        100 
7120 <a name="l7100"><span class="ln">7100 </span></a>        FF 
7121 <a name="l7101"><span class="ln">7101 </span></a>        &quot;&quot;&quot;</span><span class="s1">)</span>
7122 <a name="l7102"><span class="ln">7102 </span></a>
7123 <a name="l7103"><span class="ln">7103 </span></a>    <span class="s3">import </span><span class="s1">uuid</span>
7124 <a name="l7104"><span class="ln">7104 </span></a>    <span class="s1">pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))</span>
7125 <a name="l7105"><span class="ln">7105 </span></a>    <span class="s1">pyparsing_common.uuid.runTests(</span><span class="s2">&quot;&quot;&quot; 
7126 <a name="l7106"><span class="ln">7106 </span></a>        12345678-1234-5678-1234-567812345678 
7127 <a name="l7107"><span class="ln">7107 </span></a>        &quot;&quot;&quot;</span><span class="s1">)</span>
7128 <a name="l7108"><span class="ln">7108 </span></a></pre>
7129 </body>
7130 </html>